// chrome/browser/glic/host/glic.mojom.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 "chrome/browser/glic/host/glic.mojom.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 "chrome/browser/glic/host/glic.mojom-params-data.h"
#include "chrome/browser/glic/host/glic.mojom-shared-message-ids.h"

#include "chrome/browser/glic/host/glic.mojom-import-headers.h"
#include "chrome/browser/glic/host/glic.mojom-test-utils.h"


namespace glic::mojom {
GeminiEnterpriseSettings::GeminiEnterpriseSettings()
    : project_id(),
      app_id(),
      location() {}

GeminiEnterpriseSettings::GeminiEnterpriseSettings(
    const std::string& project_id_in,
    const std::string& app_id_in,
    const std::string& location_in)
    : project_id(std::move(project_id_in)),
      app_id(std::move(app_id_in)),
      location(std::move(location_in)) {}

GeminiEnterpriseSettings::~GeminiEnterpriseSettings() = default;
size_t GeminiEnterpriseSettings::Hash(size_t seed) const {
  seed = mojo::internal::Hash(seed, this->project_id);
  seed = mojo::internal::Hash(seed, this->app_id);
  seed = mojo::internal::Hash(seed, this->location);
  return seed;
}

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

bool GeminiEnterpriseSettings::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ProfileEnablement::ProfileEnablement()
    : feature_enabled(),
      is_regular_profile(),
      is_rolled_out(),
      primary_account_is_capable(),
      primary_account_is_fully_signed_in(),
      allowed_by_chrome_policy(),
      allowed_by_remote_admin(),
      allowed_by_remote_other(),
      fre_is_consented(),
      allowed_by_country_filter(),
      allowed_by_locale_filter(),
      actuation_is_consented(),
      live_allowed(),
      share_image_allowed(),
      gemini_enterprise_settings(),
      actuation_eligibility(),
      glic_api_actuation_eligibility(),
      glic_experimental_triggering_state() {}

ProfileEnablement::ProfileEnablement(
    bool feature_enabled_in,
    bool is_regular_profile_in,
    bool is_rolled_out_in,
    bool primary_account_is_capable_in,
    bool primary_account_is_fully_signed_in_in,
    bool allowed_by_chrome_policy_in,
    bool allowed_by_remote_admin_in,
    bool allowed_by_remote_other_in,
    bool fre_is_consented_in,
    bool allowed_by_country_filter_in,
    bool allowed_by_locale_filter_in,
    bool actuation_is_consented_in,
    bool live_allowed_in,
    bool share_image_allowed_in,
    GeminiEnterpriseSettingsPtr gemini_enterprise_settings_in,
    ActuationEligibility actuation_eligibility_in,
    ActuationEligibility glic_api_actuation_eligibility_in,
    GlicExperimentalTriggeringState glic_experimental_triggering_state_in)
    : feature_enabled(std::move(feature_enabled_in)),
      is_regular_profile(std::move(is_regular_profile_in)),
      is_rolled_out(std::move(is_rolled_out_in)),
      primary_account_is_capable(std::move(primary_account_is_capable_in)),
      primary_account_is_fully_signed_in(std::move(primary_account_is_fully_signed_in_in)),
      allowed_by_chrome_policy(std::move(allowed_by_chrome_policy_in)),
      allowed_by_remote_admin(std::move(allowed_by_remote_admin_in)),
      allowed_by_remote_other(std::move(allowed_by_remote_other_in)),
      fre_is_consented(std::move(fre_is_consented_in)),
      allowed_by_country_filter(std::move(allowed_by_country_filter_in)),
      allowed_by_locale_filter(std::move(allowed_by_locale_filter_in)),
      actuation_is_consented(std::move(actuation_is_consented_in)),
      live_allowed(std::move(live_allowed_in)),
      share_image_allowed(std::move(share_image_allowed_in)),
      gemini_enterprise_settings(std::move(gemini_enterprise_settings_in)),
      actuation_eligibility(std::move(actuation_eligibility_in)),
      glic_api_actuation_eligibility(std::move(glic_api_actuation_eligibility_in)),
      glic_experimental_triggering_state(std::move(glic_experimental_triggering_state_in)) {}

ProfileEnablement::~ProfileEnablement() = default;

void ProfileEnablement::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "feature_enabled"), this->feature_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_regular_profile"), this->is_regular_profile,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_rolled_out"), this->is_rolled_out,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "primary_account_is_capable"), this->primary_account_is_capable,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "primary_account_is_fully_signed_in"), this->primary_account_is_fully_signed_in,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_by_chrome_policy"), this->allowed_by_chrome_policy,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_by_remote_admin"), this->allowed_by_remote_admin,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_by_remote_other"), this->allowed_by_remote_other,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fre_is_consented"), this->fre_is_consented,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_by_country_filter"), this->allowed_by_country_filter,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_by_locale_filter"), this->allowed_by_locale_filter,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "actuation_is_consented"), this->actuation_is_consented,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "live_allowed"), this->live_allowed,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "share_image_allowed"), this->share_image_allowed,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "gemini_enterprise_settings"), this->gemini_enterprise_settings,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type GeminiEnterpriseSettingsPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "actuation_eligibility"), this->actuation_eligibility,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ActuationEligibility>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_api_actuation_eligibility"), this->glic_api_actuation_eligibility,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ActuationEligibility>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_experimental_triggering_state"), this->glic_experimental_triggering_state,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type GlicExperimentalTriggeringState>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ProfileEnablement::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ConfigInfo::ConfigInfo()
    : guest_url(),
      autopush_guest_url(),
      staging_guest_url(),
      preprod_guest_url(),
      prod_guest_url(),
      web_continuity_originating_host_url() {}

ConfigInfo::ConfigInfo(
    const ::GURL& guest_url_in,
    const ::GURL& autopush_guest_url_in,
    const ::GURL& staging_guest_url_in,
    const ::GURL& preprod_guest_url_in,
    const ::GURL& prod_guest_url_in,
    const ::GURL& web_continuity_originating_host_url_in)
    : guest_url(std::move(guest_url_in)),
      autopush_guest_url(std::move(autopush_guest_url_in)),
      staging_guest_url(std::move(staging_guest_url_in)),
      preprod_guest_url(std::move(preprod_guest_url_in)),
      prod_guest_url(std::move(prod_guest_url_in)),
      web_continuity_originating_host_url(std::move(web_continuity_originating_host_url_in)) {}

ConfigInfo::~ConfigInfo() = default;

void ConfigInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "guest_url"), this->guest_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "autopush_guest_url"), this->autopush_guest_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "staging_guest_url"), this->staging_guest_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "preprod_guest_url"), this->preprod_guest_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "prod_guest_url"), this->prod_guest_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "web_continuity_originating_host_url"), this->web_continuity_originating_host_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

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

DefaultConversation::~DefaultConversation() = default;
size_t DefaultConversation::Hash(size_t seed) const {
  return seed;
}

void DefaultConversation::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
}

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

NewConversation::~NewConversation() = default;
size_t NewConversation::Hash(size_t seed) const {
  return seed;
}

void NewConversation::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
}

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

DefaultSurfaceMojo::~DefaultSurfaceMojo() = default;
size_t DefaultSurfaceMojo::Hash(size_t seed) const {
  return seed;
}

void DefaultSurfaceMojo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
}

bool DefaultSurfaceMojo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
NewTabMojo::NewTabMojo()
    : open_in_foreground() {}

NewTabMojo::NewTabMojo(
    bool open_in_foreground_in)
    : open_in_foreground(std::move(open_in_foreground_in)) {}

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

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

bool NewTabMojo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ZssConfig::ZssConfig()
    : additional_content() {}

ZssConfig::ZssConfig(
    const std::optional<std::string>& additional_content_in)
    : additional_content(std::move(additional_content_in)) {}

ZssConfig::~ZssConfig() = default;

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

bool ZssConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
GetContextResultWithActionResultCode::GetContextResultWithActionResultCode()
    : get_context_result(),
      action_result() {}

GetContextResultWithActionResultCode::GetContextResultWithActionResultCode(
    GetContextResultPtr get_context_result_in,
    std::optional<int32_t> action_result_in)
    : get_context_result(std::move(get_context_result_in)),
      action_result(std::move(action_result_in)) {}

GetContextResultWithActionResultCode::~GetContextResultWithActionResultCode() = default;

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

bool GetContextResultWithActionResultCode::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
UserProfileInfo::UserProfileInfo()
    : avatar_icon(),
      display_name(),
      given_name(),
      local_profile_name(),
      email(),
      is_managed() {}

UserProfileInfo::UserProfileInfo(
    const ::SkBitmap& avatar_icon_in,
    const std::string& display_name_in,
    const std::string& given_name_in,
    const std::string& local_profile_name_in,
    const std::string& email_in,
    bool is_managed_in)
    : avatar_icon(std::move(avatar_icon_in)),
      display_name(std::move(display_name_in)),
      given_name(std::move(given_name_in)),
      local_profile_name(std::move(local_profile_name_in)),
      email(std::move(email_in)),
      is_managed(std::move(is_managed_in)) {}

UserProfileInfo::~UserProfileInfo() = default;

void UserProfileInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "avatar_icon"), this->avatar_icon,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::SkBitmap&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "display_name"), this->display_name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "given_name"), this->given_name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "local_profile_name"), this->local_profile_name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "email"), this->email,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_managed"), this->is_managed,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool UserProfileInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SafeBrowsingVerdict::SafeBrowsingVerdict()
    : url(),
      threat_type(),
      show_interstitial() {}

SafeBrowsingVerdict::SafeBrowsingVerdict(
    const std::string& url_in,
    SbThreatType threat_type_in,
    bool show_interstitial_in)
    : url(std::move(url_in)),
      threat_type(std::move(threat_type_in)),
      show_interstitial(std::move(show_interstitial_in)) {}

SafeBrowsingVerdict::~SafeBrowsingVerdict() = default;
size_t SafeBrowsingVerdict::Hash(size_t seed) const {
  seed = mojo::internal::Hash(seed, this->url);
  seed = mojo::internal::Hash(seed, this->threat_type);
  seed = mojo::internal::Hash(seed, this->show_interstitial);
  return seed;
}

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

bool SafeBrowsingVerdict::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CounterAbuseVerdict::CounterAbuseVerdict()
    : sb_verdict_result() {}

CounterAbuseVerdict::CounterAbuseVerdict(
    SafeBrowsingVerdictPtr sb_verdict_result_in)
    : sb_verdict_result(std::move(sb_verdict_result_in)) {}

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

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

bool CounterAbuseVerdict::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
WebClientInitialState::WebClientInitialState()
    : panel_state(),
      focused_tab_data(),
      microphone_permission_enabled(),
      location_permission_enabled(),
      tab_context_permission_enabled(),
      os_location_permission_enabled(),
      zoom_factor(),
      hotkey(),
      chrome_version(),
      platform(),
      form_factor(),
      can_attach(),
      panel_is_active(),
      browser_is_open(),
      instance_is_active(),
      enable_zero_state_suggestions(),
      enable_cached_get_user_profile_info(),
      enable_act_in_focused_tab(),
      enable_scroll_to(),
      enable_default_tab_context_setting_feature(),
      default_tab_context_setting_enabled(),
      closed_captioning_setting_enabled(),
      enable_maybe_refresh_user_status(),
      enable_multi_tab(),
      enable_get_context_actor(),
      host_capabilities(),
      enable_get_page_metadata(),
      enable_capture_region(),
      enable_web_actuation_setting_feature(),
      actuation_on_web_setting_enabled(),
      can_act_on_web(),
      enable_activate_tab(),
      enable_get_tab_by_id(),
      enable_open_password_manager_settings_page(),
      enable_trust_first_onboarding(),
      onboarding_completed(),
      enable_skills(),
      enable_get_tab_favicon_by_id(),
      enable_process_counter_abuse_verdict(),
      gemini_enterprise_settings(),
      enable_gmail_otp_opt_in(),
      enable_gmail_otp_confirmation(),
      file_upload_policy_state() {}

WebClientInitialState::WebClientInitialState(
    PanelStatePtr panel_state_in,
    FocusedTabDataPtr focused_tab_data_in,
    bool microphone_permission_enabled_in,
    bool location_permission_enabled_in,
    bool tab_context_permission_enabled_in,
    bool os_location_permission_enabled_in,
    double zoom_factor_in,
    const std::string& hotkey_in,
    const ::base::Version& chrome_version_in,
    Platform platform_in,
    FormFactor form_factor_in,
    bool can_attach_in,
    bool panel_is_active_in,
    bool browser_is_open_in,
    bool instance_is_active_in,
    bool enable_zero_state_suggestions_in,
    bool enable_cached_get_user_profile_info_in,
    bool enable_act_in_focused_tab_in,
    bool enable_scroll_to_in,
    bool enable_default_tab_context_setting_feature_in,
    bool default_tab_context_setting_enabled_in,
    bool closed_captioning_setting_enabled_in,
    bool enable_maybe_refresh_user_status_in,
    bool enable_multi_tab_in,
    bool enable_get_context_actor_in,
    std::vector<HostCapability> host_capabilities_in,
    bool enable_get_page_metadata_in,
    bool enable_capture_region_in,
    bool enable_web_actuation_setting_feature_in,
    bool actuation_on_web_setting_enabled_in,
    bool can_act_on_web_in,
    bool enable_activate_tab_in,
    bool enable_get_tab_by_id_in,
    bool enable_open_password_manager_settings_page_in,
    bool enable_trust_first_onboarding_in,
    bool onboarding_completed_in,
    bool enable_skills_in,
    bool enable_get_tab_favicon_by_id_in,
    bool enable_process_counter_abuse_verdict_in,
    GeminiEnterpriseSettingsPtr gemini_enterprise_settings_in,
    bool enable_gmail_otp_opt_in_in,
    bool enable_gmail_otp_confirmation_in,
    FileUploadPolicyState file_upload_policy_state_in)
    : panel_state(std::move(panel_state_in)),
      focused_tab_data(std::move(focused_tab_data_in)),
      microphone_permission_enabled(std::move(microphone_permission_enabled_in)),
      location_permission_enabled(std::move(location_permission_enabled_in)),
      tab_context_permission_enabled(std::move(tab_context_permission_enabled_in)),
      os_location_permission_enabled(std::move(os_location_permission_enabled_in)),
      zoom_factor(std::move(zoom_factor_in)),
      hotkey(std::move(hotkey_in)),
      chrome_version(std::move(chrome_version_in)),
      platform(std::move(platform_in)),
      form_factor(std::move(form_factor_in)),
      can_attach(std::move(can_attach_in)),
      panel_is_active(std::move(panel_is_active_in)),
      browser_is_open(std::move(browser_is_open_in)),
      instance_is_active(std::move(instance_is_active_in)),
      enable_zero_state_suggestions(std::move(enable_zero_state_suggestions_in)),
      enable_cached_get_user_profile_info(std::move(enable_cached_get_user_profile_info_in)),
      enable_act_in_focused_tab(std::move(enable_act_in_focused_tab_in)),
      enable_scroll_to(std::move(enable_scroll_to_in)),
      enable_default_tab_context_setting_feature(std::move(enable_default_tab_context_setting_feature_in)),
      default_tab_context_setting_enabled(std::move(default_tab_context_setting_enabled_in)),
      closed_captioning_setting_enabled(std::move(closed_captioning_setting_enabled_in)),
      enable_maybe_refresh_user_status(std::move(enable_maybe_refresh_user_status_in)),
      enable_multi_tab(std::move(enable_multi_tab_in)),
      enable_get_context_actor(std::move(enable_get_context_actor_in)),
      host_capabilities(std::move(host_capabilities_in)),
      enable_get_page_metadata(std::move(enable_get_page_metadata_in)),
      enable_capture_region(std::move(enable_capture_region_in)),
      enable_web_actuation_setting_feature(std::move(enable_web_actuation_setting_feature_in)),
      actuation_on_web_setting_enabled(std::move(actuation_on_web_setting_enabled_in)),
      can_act_on_web(std::move(can_act_on_web_in)),
      enable_activate_tab(std::move(enable_activate_tab_in)),
      enable_get_tab_by_id(std::move(enable_get_tab_by_id_in)),
      enable_open_password_manager_settings_page(std::move(enable_open_password_manager_settings_page_in)),
      enable_trust_first_onboarding(std::move(enable_trust_first_onboarding_in)),
      onboarding_completed(std::move(onboarding_completed_in)),
      enable_skills(std::move(enable_skills_in)),
      enable_get_tab_favicon_by_id(std::move(enable_get_tab_favicon_by_id_in)),
      enable_process_counter_abuse_verdict(std::move(enable_process_counter_abuse_verdict_in)),
      gemini_enterprise_settings(std::move(gemini_enterprise_settings_in)),
      enable_gmail_otp_opt_in(std::move(enable_gmail_otp_opt_in_in)),
      enable_gmail_otp_confirmation(std::move(enable_gmail_otp_confirmation_in)),
      file_upload_policy_state(std::move(file_upload_policy_state_in)) {}

WebClientInitialState::~WebClientInitialState() = default;

void WebClientInitialState::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "panel_state"), this->panel_state,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type PanelStatePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "focused_tab_data"), this->focused_tab_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type FocusedTabDataPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "microphone_permission_enabled"), this->microphone_permission_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "location_permission_enabled"), this->location_permission_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tab_context_permission_enabled"), this->tab_context_permission_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "os_location_permission_enabled"), this->os_location_permission_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "zoom_factor"), this->zoom_factor,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type double>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "hotkey"), this->hotkey,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "chrome_version"), this->chrome_version,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::Version&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "platform"), this->platform,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type Platform>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "form_factor"), this->form_factor,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type FormFactor>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "can_attach"), this->can_attach,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "panel_is_active"), this->panel_is_active,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "browser_is_open"), this->browser_is_open,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "instance_is_active"), this->instance_is_active,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_zero_state_suggestions"), this->enable_zero_state_suggestions,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_cached_get_user_profile_info"), this->enable_cached_get_user_profile_info,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_act_in_focused_tab"), this->enable_act_in_focused_tab,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_scroll_to"), this->enable_scroll_to,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_default_tab_context_setting_feature"), this->enable_default_tab_context_setting_feature,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "default_tab_context_setting_enabled"), this->default_tab_context_setting_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "closed_captioning_setting_enabled"), this->closed_captioning_setting_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_maybe_refresh_user_status"), this->enable_maybe_refresh_user_status,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_multi_tab"), this->enable_multi_tab,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_get_context_actor"), this->enable_get_context_actor,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "host_capabilities"), this->host_capabilities,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<HostCapability>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_get_page_metadata"), this->enable_get_page_metadata,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_capture_region"), this->enable_capture_region,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_web_actuation_setting_feature"), this->enable_web_actuation_setting_feature,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "actuation_on_web_setting_enabled"), this->actuation_on_web_setting_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "can_act_on_web"), this->can_act_on_web,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_activate_tab"), this->enable_activate_tab,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_get_tab_by_id"), this->enable_get_tab_by_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_open_password_manager_settings_page"), this->enable_open_password_manager_settings_page,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_trust_first_onboarding"), this->enable_trust_first_onboarding,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "onboarding_completed"), this->onboarding_completed,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_skills"), this->enable_skills,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_get_tab_favicon_by_id"), this->enable_get_tab_favicon_by_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_process_counter_abuse_verdict"), this->enable_process_counter_abuse_verdict,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "gemini_enterprise_settings"), this->gemini_enterprise_settings,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type GeminiEnterpriseSettingsPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_gmail_otp_opt_in"), this->enable_gmail_otp_opt_in,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enable_gmail_otp_confirmation"), this->enable_gmail_otp_confirmation,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "file_upload_policy_state"), this->file_upload_policy_state,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type FileUploadPolicyState>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool WebClientInitialState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ScreenshotCollectionOptions::ScreenshotCollectionOptions()
    : max_width(),
      max_height(),
      screenshot_image_format(),
      screenshot_compression_quality() {}

ScreenshotCollectionOptions::ScreenshotCollectionOptions(
    uint32_t max_width_in,
    uint32_t max_height_in,
    ::page_content_annotations::ScreenshotOptions::ScreenshotImageFormat screenshot_image_format_in,
    ::page_content_annotations::ScreenshotOptions::ScreenshotCompressionQuality screenshot_compression_quality_in)
    : max_width(std::move(max_width_in)),
      max_height(std::move(max_height_in)),
      screenshot_image_format(std::move(screenshot_image_format_in)),
      screenshot_compression_quality(std::move(screenshot_compression_quality_in)) {}

ScreenshotCollectionOptions::~ScreenshotCollectionOptions() = default;

void ScreenshotCollectionOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "max_width"), this->max_width,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "max_height"), this->max_height,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "screenshot_image_format"), this->screenshot_image_format,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::page_content_annotations::ScreenshotOptions::ScreenshotImageFormat>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "screenshot_compression_quality"), this->screenshot_compression_quality,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::page_content_annotations::ScreenshotOptions::ScreenshotCompressionQuality>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ScreenshotCollectionOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TabContextOptions::TabContextOptions()
    : inner_text(),
      inner_text_bytes_limit(),
      viewport_screenshot(),
      annotated_page_content(),
      max_meta_tags(),
      pdf_data(),
      pdf_size_limit(),
      annotated_page_content_mode(0U),
      screenshot_collection_options() {}

TabContextOptions::TabContextOptions(
    bool inner_text_in,
    uint32_t inner_text_bytes_limit_in,
    bool viewport_screenshot_in,
    bool annotated_page_content_in,
    uint32_t max_meta_tags_in,
    bool pdf_data_in,
    uint32_t pdf_size_limit_in,
    uint32_t annotated_page_content_mode_in,
    const ::page_content_annotations::ScreenshotOptions::ScreenshotCollectionOptions& screenshot_collection_options_in)
    : inner_text(std::move(inner_text_in)),
      inner_text_bytes_limit(std::move(inner_text_bytes_limit_in)),
      viewport_screenshot(std::move(viewport_screenshot_in)),
      annotated_page_content(std::move(annotated_page_content_in)),
      max_meta_tags(std::move(max_meta_tags_in)),
      pdf_data(std::move(pdf_data_in)),
      pdf_size_limit(std::move(pdf_size_limit_in)),
      annotated_page_content_mode(std::move(annotated_page_content_mode_in)),
      screenshot_collection_options(std::move(screenshot_collection_options_in)) {}

TabContextOptions::~TabContextOptions() = default;

void TabContextOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "inner_text"), this->inner_text,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "inner_text_bytes_limit"), this->inner_text_bytes_limit,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "viewport_screenshot"), this->viewport_screenshot,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "annotated_page_content"), this->annotated_page_content,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "max_meta_tags"), this->max_meta_tags,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "pdf_data"), this->pdf_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "pdf_size_limit"), this->pdf_size_limit,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "annotated_page_content_mode"), this->annotated_page_content_mode,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "screenshot_collection_options"), this->screenshot_collection_options,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::page_content_annotations::ScreenshotOptions::ScreenshotCollectionOptions&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TabContextOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
GetPinCandidatesOptions::GetPinCandidatesOptions()
    : max_candidates(),
      query() {}

GetPinCandidatesOptions::GetPinCandidatesOptions(
    uint32_t max_candidates_in,
    const std::optional<std::string>& query_in)
    : max_candidates(std::move(max_candidates_in)),
      query(std::move(query_in)) {}

GetPinCandidatesOptions::~GetPinCandidatesOptions() = default;

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

bool GetPinCandidatesOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ScrollToParams::ScrollToParams()
    : selector(),
      highlight(),
      document_id(),
      url() {}

ScrollToParams::ScrollToParams(
    ScrollToSelectorPtr selector_in,
    bool highlight_in,
    const std::optional<::base::UnguessableToken>& document_id_in,
    const std::optional<::GURL>& url_in)
    : selector(std::move(selector_in)),
      highlight(std::move(highlight_in)),
      document_id(std::move(document_id_in)),
      url(std::move(url_in)) {}

ScrollToParams::~ScrollToParams() = default;

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

bool ScrollToParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ScrollToTextSelector::ScrollToTextSelector()
    : text(),
      search_range_start_node_id() {}

ScrollToTextSelector::ScrollToTextSelector(
    const std::string& text_in,
    std::optional<int32_t> search_range_start_node_id_in)
    : text(std::move(text_in)),
      search_range_start_node_id(std::move(search_range_start_node_id_in)) {}

ScrollToTextSelector::~ScrollToTextSelector() = default;

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

bool ScrollToTextSelector::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ScrollToTextFragmentSelector::ScrollToTextFragmentSelector()
    : text_start(),
      text_end(),
      search_range_start_node_id() {}

ScrollToTextFragmentSelector::ScrollToTextFragmentSelector(
    const std::string& text_start_in,
    const std::string& text_end_in,
    std::optional<int32_t> search_range_start_node_id_in)
    : text_start(std::move(text_start_in)),
      text_end(std::move(text_end_in)),
      search_range_start_node_id(std::move(search_range_start_node_id_in)) {}

ScrollToTextFragmentSelector::~ScrollToTextFragmentSelector() = default;

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

bool ScrollToTextFragmentSelector::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ScrollToNodeSelector::ScrollToNodeSelector()
    : node_id() {}

ScrollToNodeSelector::ScrollToNodeSelector(
    int32_t node_id_in)
    : node_id(std::move(node_id_in)) {}

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

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

bool ScrollToNodeSelector::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SuggestionContent::SuggestionContent()
    : suggestion() {}

SuggestionContent::SuggestionContent(
    const std::string& suggestion_in)
    : suggestion(std::move(suggestion_in)) {}

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

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

bool SuggestionContent::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SkillPreview::SkillPreview()
    : id(),
      name(),
      icon(),
      source(),
      description(),
      curated_by(),
      image_url(),
      category(),
      creation_time() {}

SkillPreview::SkillPreview(
    const std::string& id_in,
    const std::string& name_in,
    const std::string& icon_in,
    SkillSource source_in,
    const std::string& description_in,
    const std::optional<std::string>& curated_by_in,
    const std::optional<::GURL>& image_url_in,
    const std::optional<std::string>& category_in,
    std::optional<::base::Time> creation_time_in)
    : id(std::move(id_in)),
      name(std::move(name_in)),
      icon(std::move(icon_in)),
      source(std::move(source_in)),
      description(std::move(description_in)),
      curated_by(std::move(curated_by_in)),
      image_url(std::move(image_url_in)),
      category(std::move(category_in)),
      creation_time(std::move(creation_time_in)) {}

SkillPreview::~SkillPreview() = default;

void SkillPreview::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "icon"), this->icon,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "source"), this->source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type SkillSource>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "description"), this->description,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "curated_by"), this->curated_by,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "image_url"), this->image_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::GURL>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "category"), this->category,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "creation_time"), this->creation_time,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::base::Time>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SkillPreview::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
Skill::Skill()
    : preview(),
      prompt(),
      source_skill_id() {}

Skill::Skill(
    SkillPreviewPtr preview_in,
    const std::string& prompt_in,
    const std::optional<std::string>& source_skill_id_in)
    : preview(std::move(preview_in)),
      prompt(std::move(prompt_in)),
      source_skill_id(std::move(source_skill_id_in)) {}

Skill::~Skill() = default;

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

bool Skill::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CreateSkillRequest::CreateSkillRequest()
    : id(),
      name(),
      icon(),
      source(),
      prompt(),
      description() {}

CreateSkillRequest::CreateSkillRequest(
    const std::string& id_in,
    const std::string& name_in,
    const std::string& icon_in,
    SkillSource source_in,
    const std::string& prompt_in,
    const std::string& description_in)
    : id(std::move(id_in)),
      name(std::move(name_in)),
      icon(std::move(icon_in)),
      source(std::move(source_in)),
      prompt(std::move(prompt_in)),
      description(std::move(description_in)) {}

CreateSkillRequest::~CreateSkillRequest() = default;
size_t CreateSkillRequest::Hash(size_t seed) const {
  seed = mojo::internal::Hash(seed, this->id);
  seed = mojo::internal::Hash(seed, this->name);
  seed = mojo::internal::Hash(seed, this->icon);
  seed = mojo::internal::Hash(seed, this->source);
  seed = mojo::internal::Hash(seed, this->prompt);
  seed = mojo::internal::Hash(seed, this->description);
  return seed;
}

void CreateSkillRequest::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "icon"), this->icon,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "source"), this->source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type SkillSource>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "prompt"), this->prompt,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "description"), this->description,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool CreateSkillRequest::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
UpdateSkillRequest::UpdateSkillRequest()
    : id() {}

UpdateSkillRequest::UpdateSkillRequest(
    const std::string& id_in)
    : id(std::move(id_in)) {}

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

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

bool UpdateSkillRequest::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ZeroStateSuggestions::ZeroStateSuggestions()
    : suggestions(),
      tab_id(),
      url() {}

ZeroStateSuggestions::ZeroStateSuggestions(
    std::vector<SuggestionContentPtr> suggestions_in,
    int32_t tab_id_in,
    const ::GURL& url_in)
    : suggestions(std::move(suggestions_in)),
      tab_id(std::move(tab_id_in)),
      url(std::move(url_in)) {}

ZeroStateSuggestions::~ZeroStateSuggestions() = default;

void ZeroStateSuggestions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "suggestions"), this->suggestions,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<SuggestionContentPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tab_id"), this->tab_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ZeroStateSuggestions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ZeroStateSuggestionsV2::ZeroStateSuggestionsV2()
    : suggestions(),
      is_pending(),
      invocation_source() {}

ZeroStateSuggestionsV2::ZeroStateSuggestionsV2(
    std::vector<SuggestionContentPtr> suggestions_in,
    bool is_pending_in,
    InvocationSource invocation_source_in)
    : suggestions(std::move(suggestions_in)),
      is_pending(std::move(is_pending_in)),
      invocation_source(std::move(invocation_source_in)) {}

ZeroStateSuggestionsV2::~ZeroStateSuggestionsV2() = default;

void ZeroStateSuggestionsV2::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "suggestions"), this->suggestions,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<SuggestionContentPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_pending"), this->is_pending,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "invocation_source"), this->invocation_source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type InvocationSource>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ZeroStateSuggestionsV2::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ZeroStateSuggestionsOptions::ZeroStateSuggestionsOptions()
    : is_first_run(),
      supported_tools() {}

ZeroStateSuggestionsOptions::ZeroStateSuggestionsOptions(
    bool is_first_run_in,
    std::vector<std::string> supported_tools_in)
    : is_first_run(std::move(is_first_run_in)),
      supported_tools(std::move(supported_tools_in)) {}

ZeroStateSuggestionsOptions::~ZeroStateSuggestionsOptions() = default;

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

bool ZeroStateSuggestionsOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PinCandidate::PinCandidate()
    : tab_data() {}

PinCandidate::PinCandidate(
    TabDataPtr tab_data_in)
    : tab_data(std::move(tab_data_in)) {}

PinCandidate::~PinCandidate() = default;

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

bool PinCandidate::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PinTabsOptions::PinTabsOptions()
    : pin_trigger() {}

PinTabsOptions::PinTabsOptions(
    PinTrigger pin_trigger_in)
    : pin_trigger(std::move(pin_trigger_in)) {}

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

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

bool PinTabsOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
UnpinTabsOptions::UnpinTabsOptions()
    : unpin_trigger() {}

UnpinTabsOptions::UnpinTabsOptions(
    UnpinTrigger unpin_trigger_in)
    : unpin_trigger(std::move(unpin_trigger_in)) {}

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

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

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

OpenPinnedTabPickerOptions::~OpenPinnedTabPickerOptions() = default;
size_t OpenPinnedTabPickerOptions::Hash(size_t seed) const {
  return seed;
}

void OpenPinnedTabPickerOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
}

bool OpenPinnedTabPickerOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CreateActorTabOptions::CreateActorTabOptions()
    : initiator_tab_id(),
      initiator_window_id(),
      open_in_background() {}

CreateActorTabOptions::CreateActorTabOptions(
    std::optional<int32_t> initiator_tab_id_in,
    std::optional<int32_t> initiator_window_id_in,
    bool open_in_background_in)
    : initiator_tab_id(std::move(initiator_tab_id_in)),
      initiator_window_id(std::move(initiator_window_id_in)),
      open_in_background(std::move(open_in_background_in)) {}

CreateActorTabOptions::~CreateActorTabOptions() = default;

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

bool CreateActorTabOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CaptureRegionParams::CaptureRegionParams()
    : tab_id(),
      options() {}

CaptureRegionParams::CaptureRegionParams(
    int32_t tab_id_in,
    TabContextOptionsPtr options_in)
    : tab_id(std::move(tab_id_in)),
      options(std::move(options_in)) {}

CaptureRegionParams::~CaptureRegionParams() = default;

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

bool CaptureRegionParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ActivateTabOptions::ActivateTabOptions()
    : pattern(""),
      fallback_window_id() {}

ActivateTabOptions::ActivateTabOptions(
    const std::string& pattern_in,
    std::optional<int32_t> fallback_window_id_in)
    : pattern(std::move(pattern_in)),
      fallback_window_id(std::move(fallback_window_id_in)) {}

ActivateTabOptions::~ActivateTabOptions() = default;

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

bool ActivateTabOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CreateTabOptions::CreateTabOptions()
    : open_in_background(),
      window_id() {}

CreateTabOptions::CreateTabOptions(
    bool open_in_background_in,
    std::optional<int32_t> window_id_in)
    : open_in_background(std::move(open_in_background_in)),
      window_id(std::move(window_id_in)) {}

CreateTabOptions::~CreateTabOptions() = default;

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

bool CreateTabOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ConversationInfo::ConversationInfo()
    : conversation_id(),
      conversation_title(),
      client_data(),
      turn_id() {}

ConversationInfo::ConversationInfo(
    const std::string& conversation_id_in,
    const std::string& conversation_title_in,
    const std::optional<std::string>& client_data_in,
    const std::optional<std::string>& turn_id_in)
    : conversation_id(std::move(conversation_id_in)),
      conversation_title(std::move(conversation_title_in)),
      client_data(std::move(client_data_in)),
      turn_id(std::move(turn_id_in)) {}

ConversationInfo::~ConversationInfo() = default;

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

bool ConversationInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PanelOpeningData::PanelOpeningData()
    : panel_state(),
      invocation_source(),
      prompt_suggestion(),
      auto_send(),
      skill_to_invoke(),
      recently_active_conversations(),
      conversation_info(),
      fre_override(FreOverride::kUnspecified) {}

PanelOpeningData::PanelOpeningData(
    PanelStatePtr panel_state_in,
    InvocationSource invocation_source_in,
    const std::optional<std::string>& prompt_suggestion_in,
    bool auto_send_in,
    SkillPtr skill_to_invoke_in,
    std::optional<std::vector<ConversationInfoPtr>> recently_active_conversations_in,
    ConversationInfoPtr conversation_info_in,
    FreOverride fre_override_in)
    : panel_state(std::move(panel_state_in)),
      invocation_source(std::move(invocation_source_in)),
      prompt_suggestion(std::move(prompt_suggestion_in)),
      auto_send(std::move(auto_send_in)),
      skill_to_invoke(std::move(skill_to_invoke_in)),
      recently_active_conversations(std::move(recently_active_conversations_in)),
      conversation_info(std::move(conversation_info_in)),
      fre_override(std::move(fre_override_in)) {}

PanelOpeningData::~PanelOpeningData() = default;

void PanelOpeningData::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "panel_state"), this->panel_state,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type PanelStatePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "invocation_source"), this->invocation_source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type InvocationSource>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "prompt_suggestion"), this->prompt_suggestion,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "auto_send"), this->auto_send,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "skill_to_invoke"), this->skill_to_invoke,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type SkillPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "recently_active_conversations"), this->recently_active_conversations,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<std::vector<ConversationInfoPtr>>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "conversation_info"), this->conversation_info,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ConversationInfoPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fre_override"), this->fre_override,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type FreOverride>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool PanelOpeningData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PanelState::PanelState()
    : kind(),
      window_id() {}

PanelState::PanelState(
    PanelStateKind kind_in,
    std::optional<int32_t> window_id_in)
    : kind(std::move(kind_in)),
      window_id(std::move(window_id_in)) {}

PanelState::~PanelState() = default;

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

bool PanelState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SkillsPayload::SkillsPayload()
    : skill_id(),
      skill_name(),
      skill_icon() {}

SkillsPayload::SkillsPayload(
    const std::string& skill_id_in,
    const std::string& skill_name_in,
    const std::string& skill_icon_in)
    : skill_id(std::move(skill_id_in)),
      skill_name(std::move(skill_name_in)),
      skill_icon(std::move(skill_icon_in)) {}

SkillsPayload::~SkillsPayload() = default;
size_t SkillsPayload::Hash(size_t seed) const {
  seed = mojo::internal::Hash(seed, this->skill_id);
  seed = mojo::internal::Hash(seed, this->skill_name);
  seed = mojo::internal::Hash(seed, this->skill_icon);
  return seed;
}

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

bool SkillsPayload::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
UniversalCartPayload::UniversalCartPayload()
    : serialized_metadata() {}

UniversalCartPayload::UniversalCartPayload(
    std::vector<uint8_t> serialized_metadata_in)
    : serialized_metadata(std::move(serialized_metadata_in)) {}

UniversalCartPayload::~UniversalCartPayload() = default;

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

bool UniversalCartPayload::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
InvokeOptions::InvokeOptions()
    : invocation_source(),
      prompts(),
      context(),
      auto_submit(),
      feature_mode(),
      actuation_target(),
      disable_zero_state_suggestions(),
      skill_id(),
      zss_config(),
      payload(),
      actuation_tab_id() {}

InvokeOptions::InvokeOptions(
    InvocationSource invocation_source_in,
    std::optional<std::vector<std::string>> prompts_in,
    AdditionalContextPtr context_in,
    bool auto_submit_in,
    ::glic::mojom::FeatureMode feature_mode_in,
    ActuationTarget actuation_target_in,
    bool disable_zero_state_suggestions_in,
    const std::optional<std::string>& skill_id_in,
    ZssConfigPtr zss_config_in,
    InvocationPayloadPtr payload_in)
    : invocation_source(std::move(invocation_source_in)),
      prompts(std::move(prompts_in)),
      context(std::move(context_in)),
      auto_submit(std::move(auto_submit_in)),
      feature_mode(std::move(feature_mode_in)),
      actuation_target(std::move(actuation_target_in)),
      disable_zero_state_suggestions(std::move(disable_zero_state_suggestions_in)),
      skill_id(std::move(skill_id_in)),
      zss_config(std::move(zss_config_in)),
      payload(std::move(payload_in)),
      actuation_tab_id() {}

InvokeOptions::InvokeOptions(
    InvocationSource invocation_source_in,
    std::optional<std::vector<std::string>> prompts_in,
    AdditionalContextPtr context_in,
    bool auto_submit_in,
    ::glic::mojom::FeatureMode feature_mode_in,
    ActuationTarget actuation_target_in,
    bool disable_zero_state_suggestions_in,
    const std::optional<std::string>& skill_id_in,
    ZssConfigPtr zss_config_in,
    InvocationPayloadPtr payload_in,
    std::optional<int32_t> actuation_tab_id_in)
    : invocation_source(std::move(invocation_source_in)),
      prompts(std::move(prompts_in)),
      context(std::move(context_in)),
      auto_submit(std::move(auto_submit_in)),
      feature_mode(std::move(feature_mode_in)),
      actuation_target(std::move(actuation_target_in)),
      disable_zero_state_suggestions(std::move(disable_zero_state_suggestions_in)),
      skill_id(std::move(skill_id_in)),
      zss_config(std::move(zss_config_in)),
      payload(std::move(payload_in)),
      actuation_tab_id(std::move(actuation_tab_id_in)) {}

InvokeOptions::~InvokeOptions() = default;

void InvokeOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "invocation_source"), this->invocation_source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type InvocationSource>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "prompts"), this->prompts,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<std::string>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "context"), this->context,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type AdditionalContextPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "auto_submit"), this->auto_submit,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "feature_mode"), this->feature_mode,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::FeatureMode>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "actuation_target"), this->actuation_target,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ActuationTarget>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "disable_zero_state_suggestions"), this->disable_zero_state_suggestions,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "skill_id"), this->skill_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "zss_config"), this->zss_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ZssConfigPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "payload"), this->payload,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type InvocationPayloadPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "actuation_tab_id"), this->actuation_tab_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int32_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool InvokeOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
OnResponseStoppedDetails::OnResponseStoppedDetails()
    : cause() {}

OnResponseStoppedDetails::OnResponseStoppedDetails(
    ResponseStopCause cause_in)
    : cause(std::move(cause_in)) {}

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

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

bool OnResponseStoppedDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
OpenPanelInfo::OpenPanelInfo()
    : web_client_mode(),
      panelSize(),
      resizeDuration(),
      can_user_resize() {}

OpenPanelInfo::OpenPanelInfo(
    WebClientMode web_client_mode_in,
    const std::optional<::gfx::Size>& panelSize_in,
    ::base::TimeDelta resizeDuration_in,
    bool can_user_resize_in)
    : web_client_mode(std::move(web_client_mode_in)),
      panelSize(std::move(panelSize_in)),
      resizeDuration(std::move(resizeDuration_in)),
      can_user_resize(std::move(can_user_resize_in)) {}

OpenPanelInfo::~OpenPanelInfo() = default;

void OpenPanelInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "web_client_mode"), this->web_client_mode,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type WebClientMode>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "panelSize"), this->panelSize,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::gfx::Size>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "resizeDuration"), this->resizeDuration,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::base::TimeDelta>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "can_user_resize"), this->can_user_resize,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool OpenPanelInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ContextData::ContextData()
    : mime_type(),
      data(),
      filename() {}

ContextData::ContextData(
    const std::string& mime_type_in,
    ::mojo_base::BigBuffer data_in,
    const std::optional<std::string>& filename_in)
    : mime_type(std::move(mime_type_in)),
      data(std::move(data_in)),
      filename(std::move(filename_in)) {}

ContextData::~ContextData() = default;

void ContextData::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "mime_type"), this->mime_type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "data"), this->data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::mojo_base::BigBuffer>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "filename"), this->filename,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ContextData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ParentConversationMetadata::ParentConversationMetadata()
    : conversation_id(),
      conversation_title() {}

ParentConversationMetadata::ParentConversationMetadata(
    const std::optional<std::string>& conversation_id_in,
    const std::optional<std::string>& conversation_title_in)
    : conversation_id(std::move(conversation_id_in)),
      conversation_title(std::move(conversation_title_in)) {}

ParentConversationMetadata::~ParentConversationMetadata() = default;

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

bool ParentConversationMetadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
AdditionalContext::AdditionalContext()
    : source(),
      name(),
      tab_id(),
      origin(),
      frameUrl(),
      parts() {}

AdditionalContext::AdditionalContext(
    AdditionalContextSource source_in,
    const std::optional<std::string>& name_in,
    std::optional<int32_t> tab_id_in,
    const std::optional<::url::Origin>& origin_in,
    const std::optional<::GURL>& frameUrl_in,
    std::vector<AdditionalContextPartPtr> parts_in)
    : source(std::move(source_in)),
      name(std::move(name_in)),
      tab_id(std::move(tab_id_in)),
      origin(std::move(origin_in)),
      frameUrl(std::move(frameUrl_in)),
      parts(std::move(parts_in)) {}

AdditionalContext::~AdditionalContext() = default;

void AdditionalContext::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "source"), this->source,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type AdditionalContextSource>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tab_id"), this->tab_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int32_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "origin"), this->origin,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::url::Origin>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "frameUrl"), this->frameUrl,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::GURL>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "parts"), this->parts,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<AdditionalContextPartPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool AdditionalContext::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ExperimentalTriggeringUpdate::ExperimentalTriggeringUpdate()
    : type(),
      data(),
      metadata() {}

ExperimentalTriggeringUpdate::ExperimentalTriggeringUpdate(
    ExperimentalTriggeringUpdateType type_in,
    const std::string& data_in,
    const std::optional<base::flat_map<std::string, std::string>>& metadata_in)
    : type(std::move(type_in)),
      data(std::move(data_in)),
      metadata(std::move(metadata_in)) {}

ExperimentalTriggeringUpdate::~ExperimentalTriggeringUpdate() = default;

void ExperimentalTriggeringUpdate::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 ExperimentalTriggeringUpdateType>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "data"), this->data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "metadata"), this->metadata,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<base::flat_map<std::string, std::string>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ExperimentalTriggeringUpdate::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TabContextResult::TabContextResult()
    : tab_data(),
      web_page_data(),
      viewport_screenshot(),
      screenshot_info(),
      pdf_document_data(),
      annotated_page_data() {}

TabContextResult::TabContextResult(
    TabDataPtr tab_data_in,
    WebPageDataPtr web_page_data_in,
    ScreenshotPtr viewport_screenshot_in,
    std::optional<::mojo_base::ProtoWrapper> screenshot_info_in,
    PdfDocumentDataPtr pdf_document_data_in,
    AnnotatedPageDataPtr annotated_page_data_in)
    : tab_data(std::move(tab_data_in)),
      web_page_data(std::move(web_page_data_in)),
      viewport_screenshot(std::move(viewport_screenshot_in)),
      screenshot_info(std::move(screenshot_info_in)),
      pdf_document_data(std::move(pdf_document_data_in)),
      annotated_page_data(std::move(annotated_page_data_in)) {}

TabContextResult::~TabContextResult() = default;

void TabContextResult::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tab_data"), this->tab_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type TabDataPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "web_page_data"), this->web_page_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type WebPageDataPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "viewport_screenshot"), this->viewport_screenshot,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ScreenshotPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "screenshot_info"), this->screenshot_info,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::mojo_base::ProtoWrapper>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "pdf_document_data"), this->pdf_document_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type PdfDocumentDataPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "annotated_page_data"), this->annotated_page_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type AnnotatedPageDataPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TabContextResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
WebPageData::WebPageData()
    : main_document() {}

WebPageData::WebPageData(
    DocumentDataPtr main_document_in)
    : main_document(std::move(main_document_in)) {}

WebPageData::~WebPageData() = default;

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

bool WebPageData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DocumentData::DocumentData()
    : origin(),
      inner_text(),
      inner_text_truncated() {}

DocumentData::DocumentData(
    const ::url::Origin& origin_in,
    const std::string& inner_text_in,
    bool inner_text_truncated_in)
    : origin(std::move(origin_in)),
      inner_text(std::move(inner_text_in)),
      inner_text_truncated(std::move(inner_text_truncated_in)) {}

DocumentData::~DocumentData() = default;

void DocumentData::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 ::url::Origin&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "inner_text"), this->inner_text,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "inner_text_truncated"), this->inner_text_truncated,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DocumentData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PdfDocumentData::PdfDocumentData()
    : origin(),
      pdf_data(),
      pdf_size_limit_exceeded() {}

PdfDocumentData::PdfDocumentData(
    const ::url::Origin& origin_in,
    std::optional<std::vector<uint8_t>> pdf_data_in,
    bool pdf_size_limit_exceeded_in)
    : origin(std::move(origin_in)),
      pdf_data(std::move(pdf_data_in)),
      pdf_size_limit_exceeded(std::move(pdf_size_limit_exceeded_in)) {}

PdfDocumentData::~PdfDocumentData() = default;

void PdfDocumentData::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 ::url::Origin&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "pdf_data"), this->pdf_data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<uint8_t>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "pdf_size_limit_exceeded"), this->pdf_size_limit_exceeded,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool PdfDocumentData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TabData::TabData()
    : tab_id(),
      window_id(),
      url(),
      title(),
      favicon(),
      favicon_url(),
      document_mime_type(),
      is_observable(),
      is_media_active(),
      is_tab_content_captured(),
      is_active_in_window(),
      is_window_active(),
      lightweight_page_features() {}

TabData::TabData(
    int32_t tab_id_in,
    int32_t window_id_in,
    const ::GURL& url_in,
    const std::optional<std::string>& title_in,
    const ::SkBitmap& favicon_in,
    const std::optional<::GURL>& favicon_url_in,
    const std::string& document_mime_type_in,
    std::optional<bool> is_observable_in,
    std::optional<bool> is_media_active_in,
    std::optional<bool> is_tab_content_captured_in,
    std::optional<bool> is_active_in_window_in,
    std::optional<bool> is_window_active_in,
    std::optional<std::vector<LightweightPageFeature>> lightweight_page_features_in)
    : tab_id(std::move(tab_id_in)),
      window_id(std::move(window_id_in)),
      url(std::move(url_in)),
      title(std::move(title_in)),
      favicon(std::move(favicon_in)),
      favicon_url(std::move(favicon_url_in)),
      document_mime_type(std::move(document_mime_type_in)),
      is_observable(std::move(is_observable_in)),
      is_media_active(std::move(is_media_active_in)),
      is_tab_content_captured(std::move(is_tab_content_captured_in)),
      is_active_in_window(std::move(is_active_in_window_in)),
      is_window_active(std::move(is_window_active_in)),
      lightweight_page_features(std::move(lightweight_page_features_in)) {}

TabData::~TabData() = default;

void TabData::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tab_id"), this->tab_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "window_id"), this->window_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "title"), this->title,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "favicon"), this->favicon,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::SkBitmap&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "favicon_url"), this->favicon_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::GURL>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "document_mime_type"), this->document_mime_type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_observable"), this->is_observable,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_media_active"), this->is_media_active,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_tab_content_captured"), this->is_tab_content_captured,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_active_in_window"), this->is_active_in_window,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_window_active"), this->is_window_active,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "lightweight_page_features"), this->lightweight_page_features,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<LightweightPageFeature>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TabData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
NoFocusedTabData::NoFocusedTabData()
    : active_tab_data(),
      no_focus_reason() {}

NoFocusedTabData::NoFocusedTabData(
    TabDataPtr active_tab_data_in,
    const std::string& no_focus_reason_in)
    : active_tab_data(std::move(active_tab_data_in)),
      no_focus_reason(std::move(no_focus_reason_in)) {}

NoFocusedTabData::~NoFocusedTabData() = default;

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

bool NoFocusedTabData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
AnnotatedPageData::AnnotatedPageData()
    : annotated_page_content(),
      metadata() {}

AnnotatedPageData::AnnotatedPageData(
    std::optional<::mojo_base::ProtoWrapper> annotated_page_content_in,
    ::blink::mojom::PageMetadataPtr metadata_in)
    : annotated_page_content(std::move(annotated_page_content_in)),
      metadata(std::move(metadata_in)) {}

AnnotatedPageData::~AnnotatedPageData() = default;

void AnnotatedPageData::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "annotated_page_content"), this->annotated_page_content,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::mojo_base::ProtoWrapper>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "metadata"), this->metadata,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::blink::mojom::PageMetadataPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

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

ImageOriginAnnotations::~ImageOriginAnnotations() = default;
size_t ImageOriginAnnotations::Hash(size_t seed) const {
  return seed;
}

void ImageOriginAnnotations::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
}

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

Journal::Journal(
    std::vector<uint8_t> data_in)
    : data(std::move(data_in)) {}

Journal::~Journal() = default;

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

bool Journal::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PendingCapturedRegion::PendingCapturedRegion()
    : id(),
      region() {}

PendingCapturedRegion::PendingCapturedRegion(
    const ::base::UnguessableToken& id_in,
    CapturedRegionPtr region_in)
    : id(std::move(id_in)),
      region(std::move(region_in)) {}

PendingCapturedRegion::~PendingCapturedRegion() = default;

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

bool PendingCapturedRegion::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
CaptureRegionResult::CaptureRegionResult()
    : tab_id(),
      region() {}

CaptureRegionResult::CaptureRegionResult(
    int32_t tab_id_in,
    CapturedRegionPtr region_in)
    : tab_id(std::move(tab_id_in)),
      region(std::move(region_in)) {}

CaptureRegionResult::~CaptureRegionResult() = default;

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

bool CaptureRegionResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
Screenshot::Screenshot()
    : width_pixels(),
      height_pixels(),
      data(),
      mime_type(),
      origin_annotations(),
      encryption_scheme() {}

Screenshot::Screenshot(
    uint32_t width_pixels_in,
    uint32_t height_pixels_in,
    std::vector<uint8_t> data_in,
    const std::string& mime_type_in,
    ImageOriginAnnotationsPtr origin_annotations_in,
    ScreenshotEncryptionScheme encryption_scheme_in)
    : width_pixels(std::move(width_pixels_in)),
      height_pixels(std::move(height_pixels_in)),
      data(std::move(data_in)),
      mime_type(std::move(mime_type_in)),
      origin_annotations(std::move(origin_annotations_in)),
      encryption_scheme(std::move(encryption_scheme_in)) {}

Screenshot::~Screenshot() = default;

void Screenshot::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "width_pixels"), this->width_pixels,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "height_pixels"), this->height_pixels,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type uint32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "data"), this->data,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<uint8_t>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "mime_type"), this->mime_type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "origin_annotations"), this->origin_annotations,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ImageOriginAnnotationsPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "encryption_scheme"), this->encryption_scheme,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ScreenshotEncryptionScheme>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool Screenshot::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ImageInfo::ImageInfo()
    : caption(),
      source_origin(),
      url(),
      mime_type() {}

ImageInfo::ImageInfo(
    const std::optional<std::string>& caption_in,
    const std::optional<::url::Origin>& source_origin_in,
    const ::GURL& url_in,
    const std::optional<std::string>& mime_type_in)
    : caption(std::move(caption_in)),
      source_origin(std::move(source_origin_in)),
      url(std::move(url_in)),
      mime_type(std::move(mime_type_in)) {}

ImageInfo::~ImageInfo() = default;

void ImageInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "caption"), this->caption,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "source_origin"), this->source_origin,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::url::Origin>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "mime_type"), this->mime_type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ImageInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ImageBytesResult::ImageBytesResult()
    : bytes(),
      image_info() {}

ImageBytesResult::ImageBytesResult(
    ::mojo_base::BigBuffer bytes_in,
    ImageInfoPtr image_info_in)
    : bytes(std::move(bytes_in)),
      image_info(std::move(image_info_in)) {}

ImageBytesResult::~ImageBytesResult() = default;

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

bool ImageBytesResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
OpenSettingsOptions::OpenSettingsOptions()
    : highlightField() {}

OpenSettingsOptions::OpenSettingsOptions(
    SettingsPageField highlightField_in)
    : highlightField(std::move(highlightField_in)) {}

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

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

bool OpenSettingsOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
InvokeConversationSelectionPtr
InvokeConversationSelection::NewDefaultConversation(
    DefaultConversationPtr value) {
  return InvokeConversationSelectionPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kDefaultConversation)>,
      std::move(value));
}

InvokeConversationSelectionPtr
InvokeConversationSelection::NewNewConversation(
    NewConversationPtr value) {
  return InvokeConversationSelectionPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kNewConversation)>,
      std::move(value));
}

InvokeConversationSelectionPtr
InvokeConversationSelection::NewConversationId(
    const std::string& value) {
  return InvokeConversationSelectionPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kConversationId)>,
      std::move(value));
}

InvokeConversationSelection::InvokeConversationSelection(
    std::in_place_index_t<static_cast<size_t>(Tag::kDefaultConversation)>,
    DefaultConversationPtr value)
    : tag_(Tag::kDefaultConversation),
      data_(std::in_place_index<static_cast<size_t>(Tag::kDefaultConversation)>,
            std::move(value)) {}

InvokeConversationSelection::InvokeConversationSelection(
    std::in_place_index_t<static_cast<size_t>(Tag::kNewConversation)>,
    NewConversationPtr value)
    : tag_(Tag::kNewConversation),
      data_(std::in_place_index<static_cast<size_t>(Tag::kNewConversation)>,
            std::move(value)) {}

InvokeConversationSelection::InvokeConversationSelection(
    std::in_place_index_t<static_cast<size_t>(Tag::kConversationId)>,
    const std::string& value)
    : tag_(Tag::kConversationId),
      data_(std::in_place_index<static_cast<size_t>(Tag::kConversationId)>,
            std::move(value)) {}
InvokeConversationSelection::~InvokeConversationSelection() {
  DestroyActive();
}

void InvokeConversationSelection::set_default_conversation(DefaultConversationPtr default_conversation) {
  if (tag_ == Tag::kDefaultConversation) {
    data_.default_conversation = std::move(default_conversation);
  } else {
    DestroyActive();
    tag_ = Tag::kDefaultConversation;
    new (&data_.default_conversation) DefaultConversationPtr(
        std::move(default_conversation));
  }
}

void InvokeConversationSelection::set_new_conversation(NewConversationPtr new_conversation) {
  if (tag_ == Tag::kNewConversation) {
    data_.new_conversation = std::move(new_conversation);
  } else {
    DestroyActive();
    tag_ = Tag::kNewConversation;
    new (&data_.new_conversation) NewConversationPtr(
        std::move(new_conversation));
  }
}

void InvokeConversationSelection::set_conversation_id(const std::string& conversation_id) {
  if (tag_ == Tag::kConversationId) {
    data_.conversation_id = std::move(conversation_id);
  } else {
    DestroyActive();
    tag_ = Tag::kConversationId;
    new (&data_.conversation_id) std::string(
        std::move(conversation_id));
  }
}


InvokeConversationSelection::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kDefaultConversation)>,
    DefaultConversationPtr value)
    : default_conversation(std::move(value)) {}

InvokeConversationSelection::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kNewConversation)>,
    NewConversationPtr value)
    : new_conversation(std::move(value)) {}

InvokeConversationSelection::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kConversationId)>,
    const std::string& value)
    : conversation_id(std::move(value)) {}

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

    case Tag::kDefaultConversation:
      std::destroy_at(&data_.default_conversation);
      break;
    case Tag::kNewConversation:
      std::destroy_at(&data_.new_conversation);
      break;
    case Tag::kConversationId:
      std::destroy_at(&data_.conversation_id);
      break;
  }
}
size_t InvokeConversationSelection::Hash(size_t seed) const {
  seed = mojo::internal::HashCombine(seed, static_cast<uint32_t>(tag_));
  switch (tag_) {

    case Tag::kDefaultConversation:
      return mojo::internal::Hash(seed, data_.default_conversation);
    case Tag::kNewConversation:
      return mojo::internal::Hash(seed, data_.new_conversation);
    case Tag::kConversationId:
      return mojo::internal::Hash(seed, data_.conversation_id);
    default:
      NOTREACHED();
  }
}

bool InvokeConversationSelection::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
InvokeTargetSurfacePtr
InvokeTargetSurface::NewDefaultSurface(
    DefaultSurfaceMojoPtr value) {
  return InvokeTargetSurfacePtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kDefaultSurface)>,
      std::move(value));
}

InvokeTargetSurfacePtr
InvokeTargetSurface::NewNewTab(
    NewTabMojoPtr value) {
  return InvokeTargetSurfacePtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kNewTab)>,
      std::move(value));
}

InvokeTargetSurface::InvokeTargetSurface(
    std::in_place_index_t<static_cast<size_t>(Tag::kDefaultSurface)>,
    DefaultSurfaceMojoPtr value)
    : tag_(Tag::kDefaultSurface),
      data_(std::in_place_index<static_cast<size_t>(Tag::kDefaultSurface)>,
            std::move(value)) {}

InvokeTargetSurface::InvokeTargetSurface(
    std::in_place_index_t<static_cast<size_t>(Tag::kNewTab)>,
    NewTabMojoPtr value)
    : tag_(Tag::kNewTab),
      data_(std::in_place_index<static_cast<size_t>(Tag::kNewTab)>,
            std::move(value)) {}
InvokeTargetSurface::~InvokeTargetSurface() {
  DestroyActive();
}

void InvokeTargetSurface::set_default_surface(DefaultSurfaceMojoPtr default_surface) {
  if (tag_ == Tag::kDefaultSurface) {
    data_.default_surface = std::move(default_surface);
  } else {
    DestroyActive();
    tag_ = Tag::kDefaultSurface;
    new (&data_.default_surface) DefaultSurfaceMojoPtr(
        std::move(default_surface));
  }
}

void InvokeTargetSurface::set_new_tab(NewTabMojoPtr new_tab) {
  if (tag_ == Tag::kNewTab) {
    data_.new_tab = std::move(new_tab);
  } else {
    DestroyActive();
    tag_ = Tag::kNewTab;
    new (&data_.new_tab) NewTabMojoPtr(
        std::move(new_tab));
  }
}


InvokeTargetSurface::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kDefaultSurface)>,
    DefaultSurfaceMojoPtr value)
    : default_surface(std::move(value)) {}

InvokeTargetSurface::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kNewTab)>,
    NewTabMojoPtr value)
    : new_tab(std::move(value)) {}

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

    case Tag::kDefaultSurface:
      std::destroy_at(&data_.default_surface);
      break;
    case Tag::kNewTab:
      std::destroy_at(&data_.new_tab);
      break;
  }
}
size_t InvokeTargetSurface::Hash(size_t seed) const {
  seed = mojo::internal::HashCombine(seed, static_cast<uint32_t>(tag_));
  switch (tag_) {

    case Tag::kDefaultSurface:
      return mojo::internal::Hash(seed, data_.default_surface);
    case Tag::kNewTab:
      return mojo::internal::Hash(seed, data_.new_tab);
    default:
      NOTREACHED();
  }
}

bool InvokeTargetSurface::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
GetContextResultPtr
GetContextResult::NewErrorReason(
    const std::string& value) {
  return GetContextResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kErrorReason)>,
      std::move(value));
}

GetContextResultPtr
GetContextResult::NewTabContext(
    TabContextResultPtr value) {
  return GetContextResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kTabContext)>,
      std::move(value));
}

GetContextResult::GetContextResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
    const std::string& value)
    : tag_(Tag::kErrorReason),
      data_(std::in_place_index<static_cast<size_t>(Tag::kErrorReason)>,
            std::move(value)) {}

GetContextResult::GetContextResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
    TabContextResultPtr value)
    : tag_(Tag::kTabContext),
      data_(std::in_place_index<static_cast<size_t>(Tag::kTabContext)>,
            std::move(value)) {}
GetContextResult::~GetContextResult() {
  DestroyActive();
}

void GetContextResult::set_error_reason(const std::string& error_reason) {
  if (tag_ == Tag::kErrorReason) {
    data_.error_reason = std::move(error_reason);
  } else {
    DestroyActive();
    tag_ = Tag::kErrorReason;
    new (&data_.error_reason) std::string(
        std::move(error_reason));
  }
}

void GetContextResult::set_tab_context(TabContextResultPtr tab_context) {
  if (tag_ == Tag::kTabContext) {
    data_.tab_context = std::move(tab_context);
  } else {
    DestroyActive();
    tag_ = Tag::kTabContext;
    new (&data_.tab_context) TabContextResultPtr(
        std::move(tab_context));
  }
}


GetContextResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
    const std::string& value)
    : error_reason(std::move(value)) {}

GetContextResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
    TabContextResultPtr value)
    : tab_context(std::move(value)) {}

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

    case Tag::kErrorReason:
      std::destroy_at(&data_.error_reason);
      break;
    case Tag::kTabContext:
      std::destroy_at(&data_.tab_context);
      break;
  }
}

bool GetContextResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
CaptureScreenshotResultPtr
CaptureScreenshotResult::NewErrorReason(
    CaptureScreenshotErrorReason value) {
  return CaptureScreenshotResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kErrorReason)>,
      std::move(value));
}

CaptureScreenshotResultPtr
CaptureScreenshotResult::NewScreenshot(
    ScreenshotPtr value) {
  return CaptureScreenshotResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kScreenshot)>,
      std::move(value));
}

CaptureScreenshotResult::CaptureScreenshotResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
    CaptureScreenshotErrorReason value)
    : tag_(Tag::kErrorReason),
      data_(std::in_place_index<static_cast<size_t>(Tag::kErrorReason)>,
            std::move(value)) {}

CaptureScreenshotResult::CaptureScreenshotResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
    ScreenshotPtr value)
    : tag_(Tag::kScreenshot),
      data_(std::in_place_index<static_cast<size_t>(Tag::kScreenshot)>,
            std::move(value)) {}
CaptureScreenshotResult::~CaptureScreenshotResult() {
  DestroyActive();
}

void CaptureScreenshotResult::set_error_reason(CaptureScreenshotErrorReason error_reason) {
  if (tag_ != Tag::kErrorReason) {
    DestroyActive();
    tag_ = Tag::kErrorReason;
  }
  data_.error_reason = error_reason;
}

void CaptureScreenshotResult::set_screenshot(ScreenshotPtr screenshot) {
  if (tag_ == Tag::kScreenshot) {
    data_.screenshot = std::move(screenshot);
  } else {
    DestroyActive();
    tag_ = Tag::kScreenshot;
    new (&data_.screenshot) ScreenshotPtr(
        std::move(screenshot));
  }
}


CaptureScreenshotResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
    CaptureScreenshotErrorReason value)
    : error_reason(std::move(value)) {}

CaptureScreenshotResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
    ScreenshotPtr value)
    : screenshot(std::move(value)) {}

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

    case Tag::kErrorReason:
      std::destroy_at(&data_.error_reason);
      break;
    case Tag::kScreenshot:
      std::destroy_at(&data_.screenshot);
      break;
  }
}

bool CaptureScreenshotResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
ScrollToSelectorPtr
ScrollToSelector::NewExactText(
    ScrollToTextSelectorPtr value) {
  return ScrollToSelectorPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kExactText)>,
      std::move(value));
}

ScrollToSelectorPtr
ScrollToSelector::NewTextFragment(
    ScrollToTextFragmentSelectorPtr value) {
  return ScrollToSelectorPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kTextFragment)>,
      std::move(value));
}

ScrollToSelectorPtr
ScrollToSelector::NewNode(
    ScrollToNodeSelectorPtr value) {
  return ScrollToSelectorPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kNode)>,
      std::move(value));
}

ScrollToSelector::ScrollToSelector(
    std::in_place_index_t<static_cast<size_t>(Tag::kExactText)>,
    ScrollToTextSelectorPtr value)
    : tag_(Tag::kExactText),
      data_(std::in_place_index<static_cast<size_t>(Tag::kExactText)>,
            std::move(value)) {}

ScrollToSelector::ScrollToSelector(
    std::in_place_index_t<static_cast<size_t>(Tag::kTextFragment)>,
    ScrollToTextFragmentSelectorPtr value)
    : tag_(Tag::kTextFragment),
      data_(std::in_place_index<static_cast<size_t>(Tag::kTextFragment)>,
            std::move(value)) {}

ScrollToSelector::ScrollToSelector(
    std::in_place_index_t<static_cast<size_t>(Tag::kNode)>,
    ScrollToNodeSelectorPtr value)
    : tag_(Tag::kNode),
      data_(std::in_place_index<static_cast<size_t>(Tag::kNode)>,
            std::move(value)) {}
ScrollToSelector::~ScrollToSelector() {
  DestroyActive();
}

void ScrollToSelector::set_exact_text(ScrollToTextSelectorPtr exact_text) {
  if (tag_ == Tag::kExactText) {
    data_.exact_text = std::move(exact_text);
  } else {
    DestroyActive();
    tag_ = Tag::kExactText;
    new (&data_.exact_text) ScrollToTextSelectorPtr(
        std::move(exact_text));
  }
}

void ScrollToSelector::set_text_fragment(ScrollToTextFragmentSelectorPtr text_fragment) {
  if (tag_ == Tag::kTextFragment) {
    data_.text_fragment = std::move(text_fragment);
  } else {
    DestroyActive();
    tag_ = Tag::kTextFragment;
    new (&data_.text_fragment) ScrollToTextFragmentSelectorPtr(
        std::move(text_fragment));
  }
}

void ScrollToSelector::set_node(ScrollToNodeSelectorPtr node) {
  if (tag_ == Tag::kNode) {
    data_.node = std::move(node);
  } else {
    DestroyActive();
    tag_ = Tag::kNode;
    new (&data_.node) ScrollToNodeSelectorPtr(
        std::move(node));
  }
}


ScrollToSelector::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kExactText)>,
    ScrollToTextSelectorPtr value)
    : exact_text(std::move(value)) {}

ScrollToSelector::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kTextFragment)>,
    ScrollToTextFragmentSelectorPtr value)
    : text_fragment(std::move(value)) {}

ScrollToSelector::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kNode)>,
    ScrollToNodeSelectorPtr value)
    : node(std::move(value)) {}

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

    case Tag::kExactText:
      std::destroy_at(&data_.exact_text);
      break;
    case Tag::kTextFragment:
      std::destroy_at(&data_.text_fragment);
      break;
    case Tag::kNode:
      std::destroy_at(&data_.node);
      break;
  }
}

bool ScrollToSelector::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
InvocationPayloadPtr
InvocationPayload::NewUniversalCart(
    UniversalCartPayloadPtr value) {
  return InvocationPayloadPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kUniversalCart)>,
      std::move(value));
}

InvocationPayloadPtr
InvocationPayload::NewSkillsPayload(
    SkillsPayloadPtr value) {
  return InvocationPayloadPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSkillsPayload)>,
      std::move(value));
}

InvocationPayload::InvocationPayload(
    std::in_place_index_t<static_cast<size_t>(Tag::kUniversalCart)>,
    UniversalCartPayloadPtr value)
    : tag_(Tag::kUniversalCart),
      data_(std::in_place_index<static_cast<size_t>(Tag::kUniversalCart)>,
            std::move(value)) {}

InvocationPayload::InvocationPayload(
    std::in_place_index_t<static_cast<size_t>(Tag::kSkillsPayload)>,
    SkillsPayloadPtr value)
    : tag_(Tag::kSkillsPayload),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSkillsPayload)>,
            std::move(value)) {}
InvocationPayload::~InvocationPayload() {
  DestroyActive();
}

void InvocationPayload::set_universal_cart(UniversalCartPayloadPtr universal_cart) {
  if (tag_ == Tag::kUniversalCart) {
    data_.universal_cart = std::move(universal_cart);
  } else {
    DestroyActive();
    tag_ = Tag::kUniversalCart;
    new (&data_.universal_cart) UniversalCartPayloadPtr(
        std::move(universal_cart));
  }
}

void InvocationPayload::set_skills_payload(SkillsPayloadPtr skills_payload) {
  if (tag_ == Tag::kSkillsPayload) {
    data_.skills_payload = std::move(skills_payload);
  } else {
    DestroyActive();
    tag_ = Tag::kSkillsPayload;
    new (&data_.skills_payload) SkillsPayloadPtr(
        std::move(skills_payload));
  }
}


InvocationPayload::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kUniversalCart)>,
    UniversalCartPayloadPtr value)
    : universal_cart(std::move(value)) {}

InvocationPayload::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSkillsPayload)>,
    SkillsPayloadPtr value)
    : skills_payload(std::move(value)) {}

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

    case Tag::kUniversalCart:
      std::destroy_at(&data_.universal_cart);
      break;
    case Tag::kSkillsPayload:
      std::destroy_at(&data_.skills_payload);
      break;
  }
}

bool InvocationPayload::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
AdditionalContextPartPtr
AdditionalContextPart::NewData(
    ContextDataPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kData)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewScreenshot(
    ScreenshotPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kScreenshot)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewWebPageData(
    WebPageDataPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kWebPageData)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewAnnotatedPageData(
    AnnotatedPageDataPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kAnnotatedPageData)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewPdfDocumentData(
    PdfDocumentDataPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kPdfDocumentData)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewTabContext(
    TabContextResultPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kTabContext)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewRegion(
    CapturedRegionPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kRegion)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewPendingRegion(
    PendingCapturedRegionPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kPendingRegion)>,
      std::move(value));
}

AdditionalContextPartPtr
AdditionalContextPart::NewParentConversationMetadata(
    ParentConversationMetadataPtr value) {
  return AdditionalContextPartPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kParentConversationMetadata)>,
      std::move(value));
}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kData)>,
    ContextDataPtr value)
    : tag_(Tag::kData),
      data_(std::in_place_index<static_cast<size_t>(Tag::kData)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
    ScreenshotPtr value)
    : tag_(Tag::kScreenshot),
      data_(std::in_place_index<static_cast<size_t>(Tag::kScreenshot)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kWebPageData)>,
    WebPageDataPtr value)
    : tag_(Tag::kWebPageData),
      data_(std::in_place_index<static_cast<size_t>(Tag::kWebPageData)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kAnnotatedPageData)>,
    AnnotatedPageDataPtr value)
    : tag_(Tag::kAnnotatedPageData),
      data_(std::in_place_index<static_cast<size_t>(Tag::kAnnotatedPageData)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kPdfDocumentData)>,
    PdfDocumentDataPtr value)
    : tag_(Tag::kPdfDocumentData),
      data_(std::in_place_index<static_cast<size_t>(Tag::kPdfDocumentData)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
    TabContextResultPtr value)
    : tag_(Tag::kTabContext),
      data_(std::in_place_index<static_cast<size_t>(Tag::kTabContext)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kRegion)>,
    CapturedRegionPtr value)
    : tag_(Tag::kRegion),
      data_(std::in_place_index<static_cast<size_t>(Tag::kRegion)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kPendingRegion)>,
    PendingCapturedRegionPtr value)
    : tag_(Tag::kPendingRegion),
      data_(std::in_place_index<static_cast<size_t>(Tag::kPendingRegion)>,
            std::move(value)) {}

AdditionalContextPart::AdditionalContextPart(
    std::in_place_index_t<static_cast<size_t>(Tag::kParentConversationMetadata)>,
    ParentConversationMetadataPtr value)
    : tag_(Tag::kParentConversationMetadata),
      data_(std::in_place_index<static_cast<size_t>(Tag::kParentConversationMetadata)>,
            std::move(value)) {}
AdditionalContextPart::~AdditionalContextPart() {
  DestroyActive();
}

void AdditionalContextPart::set_data(ContextDataPtr data) {
  if (tag_ == Tag::kData) {
    data_.data = std::move(data);
  } else {
    DestroyActive();
    tag_ = Tag::kData;
    new (&data_.data) ContextDataPtr(
        std::move(data));
  }
}

void AdditionalContextPart::set_screenshot(ScreenshotPtr screenshot) {
  if (tag_ == Tag::kScreenshot) {
    data_.screenshot = std::move(screenshot);
  } else {
    DestroyActive();
    tag_ = Tag::kScreenshot;
    new (&data_.screenshot) ScreenshotPtr(
        std::move(screenshot));
  }
}

void AdditionalContextPart::set_web_page_data(WebPageDataPtr web_page_data) {
  if (tag_ == Tag::kWebPageData) {
    data_.web_page_data = std::move(web_page_data);
  } else {
    DestroyActive();
    tag_ = Tag::kWebPageData;
    new (&data_.web_page_data) WebPageDataPtr(
        std::move(web_page_data));
  }
}

void AdditionalContextPart::set_annotated_page_data(AnnotatedPageDataPtr annotated_page_data) {
  if (tag_ == Tag::kAnnotatedPageData) {
    data_.annotated_page_data = std::move(annotated_page_data);
  } else {
    DestroyActive();
    tag_ = Tag::kAnnotatedPageData;
    new (&data_.annotated_page_data) AnnotatedPageDataPtr(
        std::move(annotated_page_data));
  }
}

void AdditionalContextPart::set_pdf_document_data(PdfDocumentDataPtr pdf_document_data) {
  if (tag_ == Tag::kPdfDocumentData) {
    data_.pdf_document_data = std::move(pdf_document_data);
  } else {
    DestroyActive();
    tag_ = Tag::kPdfDocumentData;
    new (&data_.pdf_document_data) PdfDocumentDataPtr(
        std::move(pdf_document_data));
  }
}

void AdditionalContextPart::set_tab_context(TabContextResultPtr tab_context) {
  if (tag_ == Tag::kTabContext) {
    data_.tab_context = std::move(tab_context);
  } else {
    DestroyActive();
    tag_ = Tag::kTabContext;
    new (&data_.tab_context) TabContextResultPtr(
        std::move(tab_context));
  }
}

void AdditionalContextPart::set_region(CapturedRegionPtr region) {
  if (tag_ == Tag::kRegion) {
    data_.region = std::move(region);
  } else {
    DestroyActive();
    tag_ = Tag::kRegion;
    new (&data_.region) CapturedRegionPtr(
        std::move(region));
  }
}

void AdditionalContextPart::set_pending_region(PendingCapturedRegionPtr pending_region) {
  if (tag_ == Tag::kPendingRegion) {
    data_.pending_region = std::move(pending_region);
  } else {
    DestroyActive();
    tag_ = Tag::kPendingRegion;
    new (&data_.pending_region) PendingCapturedRegionPtr(
        std::move(pending_region));
  }
}

void AdditionalContextPart::set_parent_conversation_metadata(ParentConversationMetadataPtr parent_conversation_metadata) {
  if (tag_ == Tag::kParentConversationMetadata) {
    data_.parent_conversation_metadata = std::move(parent_conversation_metadata);
  } else {
    DestroyActive();
    tag_ = Tag::kParentConversationMetadata;
    new (&data_.parent_conversation_metadata) ParentConversationMetadataPtr(
        std::move(parent_conversation_metadata));
  }
}


AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kData)>,
    ContextDataPtr value)
    : data(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
    ScreenshotPtr value)
    : screenshot(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kWebPageData)>,
    WebPageDataPtr value)
    : web_page_data(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kAnnotatedPageData)>,
    AnnotatedPageDataPtr value)
    : annotated_page_data(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kPdfDocumentData)>,
    PdfDocumentDataPtr value)
    : pdf_document_data(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
    TabContextResultPtr value)
    : tab_context(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kRegion)>,
    CapturedRegionPtr value)
    : region(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kPendingRegion)>,
    PendingCapturedRegionPtr value)
    : pending_region(std::move(value)) {}

AdditionalContextPart::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kParentConversationMetadata)>,
    ParentConversationMetadataPtr value)
    : parent_conversation_metadata(std::move(value)) {}

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

    case Tag::kData:
      std::destroy_at(&data_.data);
      break;
    case Tag::kScreenshot:
      std::destroy_at(&data_.screenshot);
      break;
    case Tag::kWebPageData:
      std::destroy_at(&data_.web_page_data);
      break;
    case Tag::kAnnotatedPageData:
      std::destroy_at(&data_.annotated_page_data);
      break;
    case Tag::kPdfDocumentData:
      std::destroy_at(&data_.pdf_document_data);
      break;
    case Tag::kTabContext:
      std::destroy_at(&data_.tab_context);
      break;
    case Tag::kRegion:
      std::destroy_at(&data_.region);
      break;
    case Tag::kPendingRegion:
      std::destroy_at(&data_.pending_region);
      break;
    case Tag::kParentConversationMetadata:
      std::destroy_at(&data_.parent_conversation_metadata);
      break;
  }
}

bool AdditionalContextPart::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
FocusedTabDataPtr
FocusedTabData::NewFocusedTab(
    TabDataPtr value) {
  return FocusedTabDataPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFocusedTab)>,
      std::move(value));
}

FocusedTabDataPtr
FocusedTabData::NewNoFocusedTabData(
    NoFocusedTabDataPtr value) {
  return FocusedTabDataPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kNoFocusedTabData)>,
      std::move(value));
}

FocusedTabData::FocusedTabData(
    std::in_place_index_t<static_cast<size_t>(Tag::kFocusedTab)>,
    TabDataPtr value)
    : tag_(Tag::kFocusedTab),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFocusedTab)>,
            std::move(value)) {}

FocusedTabData::FocusedTabData(
    std::in_place_index_t<static_cast<size_t>(Tag::kNoFocusedTabData)>,
    NoFocusedTabDataPtr value)
    : tag_(Tag::kNoFocusedTabData),
      data_(std::in_place_index<static_cast<size_t>(Tag::kNoFocusedTabData)>,
            std::move(value)) {}
FocusedTabData::~FocusedTabData() {
  DestroyActive();
}

void FocusedTabData::set_focused_tab(TabDataPtr focused_tab) {
  if (tag_ == Tag::kFocusedTab) {
    data_.focused_tab = std::move(focused_tab);
  } else {
    DestroyActive();
    tag_ = Tag::kFocusedTab;
    new (&data_.focused_tab) TabDataPtr(
        std::move(focused_tab));
  }
}

void FocusedTabData::set_no_focused_tab_data(NoFocusedTabDataPtr no_focused_tab_data) {
  if (tag_ == Tag::kNoFocusedTabData) {
    data_.no_focused_tab_data = std::move(no_focused_tab_data);
  } else {
    DestroyActive();
    tag_ = Tag::kNoFocusedTabData;
    new (&data_.no_focused_tab_data) NoFocusedTabDataPtr(
        std::move(no_focused_tab_data));
  }
}


FocusedTabData::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFocusedTab)>,
    TabDataPtr value)
    : focused_tab(std::move(value)) {}

FocusedTabData::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kNoFocusedTabData)>,
    NoFocusedTabDataPtr value)
    : no_focused_tab_data(std::move(value)) {}

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

    case Tag::kFocusedTab:
      std::destroy_at(&data_.focused_tab);
      break;
    case Tag::kNoFocusedTabData:
      std::destroy_at(&data_.no_focused_tab_data);
      break;
  }
}

bool FocusedTabData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
CapturedRegionPtr
CapturedRegion::NewRect(
    const ::gfx::Rect& value) {
  return CapturedRegionPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kRect)>,
      std::move(value));
}

CapturedRegionPtr
CapturedRegion::NewPolyline(
    std::vector<::gfx::Point> value) {
  return CapturedRegionPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kPolyline)>,
      std::move(value));
}

CapturedRegion::CapturedRegion(
    std::in_place_index_t<static_cast<size_t>(Tag::kRect)>,
    const ::gfx::Rect& value)
    : tag_(Tag::kRect),
      data_(std::in_place_index<static_cast<size_t>(Tag::kRect)>,
            std::move(value)) {}

CapturedRegion::CapturedRegion(
    std::in_place_index_t<static_cast<size_t>(Tag::kPolyline)>,
    std::vector<::gfx::Point> value)
    : tag_(Tag::kPolyline),
      data_(std::in_place_index<static_cast<size_t>(Tag::kPolyline)>,
            std::move(value)) {}
CapturedRegion::~CapturedRegion() {
  DestroyActive();
}

void CapturedRegion::set_rect(const ::gfx::Rect& rect) {
  if (tag_ == Tag::kRect) {
    data_.rect = std::move(rect);
  } else {
    DestroyActive();
    tag_ = Tag::kRect;
    new (&data_.rect) ::gfx::Rect(
        std::move(rect));
  }
}

void CapturedRegion::set_polyline(std::vector<::gfx::Point> polyline) {
  if (tag_ == Tag::kPolyline) {
    data_.polyline = std::move(polyline);
  } else {
    DestroyActive();
    tag_ = Tag::kPolyline;
    new (&data_.polyline) std::vector<::gfx::Point>(
        std::move(polyline));
  }
}


CapturedRegion::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kRect)>,
    const ::gfx::Rect& value)
    : rect(std::move(value)) {}

CapturedRegion::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kPolyline)>,
    std::vector<::gfx::Point> value)
    : polyline(std::move(value)) {}

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

    case Tag::kRect:
      std::destroy_at(&data_.rect);
      break;
    case Tag::kPolyline:
      std::destroy_at(&data_.polyline);
      break;
  }
}

bool CapturedRegion::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
GetImageBytesResultPtr
GetImageBytesResult::NewImageBytes(
    ImageBytesResultPtr value) {
  return GetImageBytesResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kImageBytes)>,
      std::move(value));
}

GetImageBytesResultPtr
GetImageBytesResult::NewErrorReason(
    const std::string& value) {
  return GetImageBytesResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kErrorReason)>,
      std::move(value));
}

GetImageBytesResult::GetImageBytesResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kImageBytes)>,
    ImageBytesResultPtr value)
    : tag_(Tag::kImageBytes),
      data_(std::in_place_index<static_cast<size_t>(Tag::kImageBytes)>,
            std::move(value)) {}

GetImageBytesResult::GetImageBytesResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
    const std::string& value)
    : tag_(Tag::kErrorReason),
      data_(std::in_place_index<static_cast<size_t>(Tag::kErrorReason)>,
            std::move(value)) {}
GetImageBytesResult::~GetImageBytesResult() {
  DestroyActive();
}

void GetImageBytesResult::set_image_bytes(ImageBytesResultPtr image_bytes) {
  if (tag_ == Tag::kImageBytes) {
    data_.image_bytes = std::move(image_bytes);
  } else {
    DestroyActive();
    tag_ = Tag::kImageBytes;
    new (&data_.image_bytes) ImageBytesResultPtr(
        std::move(image_bytes));
  }
}

void GetImageBytesResult::set_error_reason(const std::string& error_reason) {
  if (tag_ == Tag::kErrorReason) {
    data_.error_reason = std::move(error_reason);
  } else {
    DestroyActive();
    tag_ = Tag::kErrorReason;
    new (&data_.error_reason) std::string(
        std::move(error_reason));
  }
}


GetImageBytesResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kImageBytes)>,
    ImageBytesResultPtr value)
    : image_bytes(std::move(value)) {}

GetImageBytesResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
    const std::string& value)
    : error_reason(std::move(value)) {}

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

    case Tag::kImageBytes:
      std::destroy_at(&data_.image_bytes);
      break;
    case Tag::kErrorReason:
      std::destroy_at(&data_.error_reason);
      break;
  }
}

bool GetImageBytesResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
ActorHandler_CreateTask_ResponseParam_ResultPtr
ActorHandler_CreateTask_ResponseParam_Result::NewSuccess(
    int32_t value) {
  return ActorHandler_CreateTask_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

ActorHandler_CreateTask_ResponseParam_ResultPtr
ActorHandler_CreateTask_ResponseParam_Result::NewFailure(
    CreateTaskErrorReason value) {
  return ActorHandler_CreateTask_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

ActorHandler_CreateTask_ResponseParam_Result::ActorHandler_CreateTask_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    int32_t value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

ActorHandler_CreateTask_ResponseParam_Result::ActorHandler_CreateTask_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    CreateTaskErrorReason value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
ActorHandler_CreateTask_ResponseParam_Result::~ActorHandler_CreateTask_ResponseParam_Result() {
  DestroyActive();
}

void ActorHandler_CreateTask_ResponseParam_Result::set_success(int32_t success) {
  if (tag_ != Tag::kSuccess) {
    DestroyActive();
    tag_ = Tag::kSuccess;
  }
  data_.success = success;
}

void ActorHandler_CreateTask_ResponseParam_Result::set_failure(CreateTaskErrorReason failure) {
  if (tag_ != Tag::kFailure) {
    DestroyActive();
    tag_ = Tag::kFailure;
  }
  data_.failure = failure;
}


ActorHandler_CreateTask_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    int32_t value)
    : success(std::move(value)) {}

ActorHandler_CreateTask_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    CreateTaskErrorReason value)
    : failure(std::move(value)) {}

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

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}
size_t ActorHandler_CreateTask_ResponseParam_Result::Hash(size_t seed) const {
  seed = mojo::internal::HashCombine(seed, static_cast<uint32_t>(tag_));
  switch (tag_) {

    case Tag::kSuccess:
      return mojo::internal::Hash(seed, data_.success);
    case Tag::kFailure:
      return mojo::internal::Hash(seed, data_.failure);
    default:
      NOTREACHED();
  }
}

bool ActorHandler_CreateTask_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
ActorHandler_PerformActions_ResponseParam_ResultPtr
ActorHandler_PerformActions_ResponseParam_Result::NewSuccess(
    ::mojo_base::ProtoWrapper value) {
  return ActorHandler_PerformActions_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

ActorHandler_PerformActions_ResponseParam_ResultPtr
ActorHandler_PerformActions_ResponseParam_Result::NewFailure(
    PerformActionsErrorReason value) {
  return ActorHandler_PerformActions_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

ActorHandler_PerformActions_ResponseParam_Result::ActorHandler_PerformActions_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    ::mojo_base::ProtoWrapper value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

ActorHandler_PerformActions_ResponseParam_Result::ActorHandler_PerformActions_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    PerformActionsErrorReason value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
ActorHandler_PerformActions_ResponseParam_Result::~ActorHandler_PerformActions_ResponseParam_Result() {
  DestroyActive();
}

void ActorHandler_PerformActions_ResponseParam_Result::set_success(::mojo_base::ProtoWrapper success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) ::mojo_base::ProtoWrapper(
        std::move(success));
  }
}

void ActorHandler_PerformActions_ResponseParam_Result::set_failure(PerformActionsErrorReason failure) {
  if (tag_ != Tag::kFailure) {
    DestroyActive();
    tag_ = Tag::kFailure;
  }
  data_.failure = failure;
}


ActorHandler_PerformActions_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    ::mojo_base::ProtoWrapper value)
    : success(std::move(value)) {}

ActorHandler_PerformActions_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    PerformActionsErrorReason value)
    : failure(std::move(value)) {}

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

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

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

PinCandidatesObserver::IPCStableHashFunction PinCandidatesObserver::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::PinCandidatesObserver>(message.name())) {
    case messages::PinCandidatesObserver::kOnPinCandidatesChanged: {
      return &PinCandidatesObserver::OnPinCandidatesChanged_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* PinCandidatesObserver::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::PinCandidatesObserver>(message.name())) {
      case messages::PinCandidatesObserver::kOnPinCandidatesChanged:
            return "Receive glic::mojom::PinCandidatesObserver::OnPinCandidatesChanged";
    }
  } else {
    switch (static_cast<messages::PinCandidatesObserver>(message.name())) {
      case messages::PinCandidatesObserver::kOnPinCandidatesChanged:
            return "Receive reply glic::mojom::PinCandidatesObserver::OnPinCandidatesChanged";
    }
  }
  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 PinCandidatesObserver::OnPinCandidatesChanged_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 = 0x66dd6fda;  // IPCStableHash for glic::mojom::PinCandidatesObserver::OnPinCandidatesChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void PinCandidatesObserverProxy::OnPinCandidatesChanged(
    std::vector<PinCandidatePtr> in_candidates) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::PinCandidatesObserver::OnPinCandidatesChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("candidates"), in_candidates,
                        "<value of type std::vector<PinCandidatePtr>>");
   });
#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::PinCandidatesObserver::kOnPinCandidatesChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::PinCandidatesObserver_OnPinCandidatesChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->candidates)::BaseType>
      candidates_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& candidates_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::PinCandidateDataView>>(
    in_candidates,
    candidates_fragment,
    &candidates_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PinCandidatesObserver::Name_);
  message.set_method_name("OnPinCandidatesChanged");
#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 PinCandidatesObserverStubDispatch::Accept(
    PinCandidatesObserver* impl,
    mojo::Message* message) {
  switch (static_cast<messages::PinCandidatesObserver>(message->header()->name)) {
    case messages::PinCandidatesObserver::kOnPinCandidatesChanged: {
      DCHECK(message->is_serialized());
      internal::PinCandidatesObserver_OnPinCandidatesChanged_Params_Data* params =
          reinterpret_cast<internal::PinCandidatesObserver_OnPinCandidatesChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PinCandidatesObserver.0
      bool success = true;
      std::vector<PinCandidatePtr> p_candidates{};
      PinCandidatesObserver_OnPinCandidatesChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadCandidates(&p_candidates))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PinCandidatesObserver::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnPinCandidatesChanged(        
        std::move(p_candidates));
      return true;
    }
  }
  return false;
}

// static
bool PinCandidatesObserverStubDispatch::AcceptWithResponder(
    PinCandidatesObserver* 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::PinCandidatesObserver>(message->header()->name)) {
    case messages::PinCandidatesObserver::kOnPinCandidatesChanged: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kPinCandidatesObserverValidationInfo[] = {
    { &internal::PinCandidatesObserver_OnPinCandidatesChanged_Params_Data::Validate,
     nullptr /* no response */},
};

bool PinCandidatesObserverRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::PinCandidatesObserver::Name_,
    kPinCandidatesObserverValidationInfo);
}

// The declaration includes the definition on other builds.

ActorClient::IPCStableHashFunction ActorClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ActorClient>(message.name())) {
    case messages::ActorClient::kRequestToShowCredentialSelectionDialog: {
      return &ActorClient::RequestToShowCredentialSelectionDialog_Sym::IPCStableHash;
    }
    case messages::ActorClient::kRequestToShowAutofillSuggestionsDialog: {
      return &ActorClient::RequestToShowAutofillSuggestionsDialog_Sym::IPCStableHash;
    }
    case messages::ActorClient::kRequestToShowUserConfirmationDialog: {
      return &ActorClient::RequestToShowUserConfirmationDialog_Sym::IPCStableHash;
    }
    case messages::ActorClient::kRequestToConfirmNavigation: {
      return &ActorClient::RequestToConfirmNavigation_Sym::IPCStableHash;
    }
    case messages::ActorClient::kNotifyActorTaskStateChanged: {
      return &ActorClient::NotifyActorTaskStateChanged_Sym::IPCStableHash;
    }
    case messages::ActorClient::kRequestToShowGmailOtpOptInDialog: {
      return &ActorClient::RequestToShowGmailOtpOptInDialog_Sym::IPCStableHash;
    }
    case messages::ActorClient::kRequestToShowGmailOtpConfirmationDialog: {
      return &ActorClient::RequestToShowGmailOtpConfirmationDialog_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ActorClient::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::ActorClient>(message.name())) {
      case messages::ActorClient::kRequestToShowCredentialSelectionDialog:
            return "Receive glic::mojom::ActorClient::RequestToShowCredentialSelectionDialog";
      case messages::ActorClient::kRequestToShowAutofillSuggestionsDialog:
            return "Receive glic::mojom::ActorClient::RequestToShowAutofillSuggestionsDialog";
      case messages::ActorClient::kRequestToShowUserConfirmationDialog:
            return "Receive glic::mojom::ActorClient::RequestToShowUserConfirmationDialog";
      case messages::ActorClient::kRequestToConfirmNavigation:
            return "Receive glic::mojom::ActorClient::RequestToConfirmNavigation";
      case messages::ActorClient::kNotifyActorTaskStateChanged:
            return "Receive glic::mojom::ActorClient::NotifyActorTaskStateChanged";
      case messages::ActorClient::kRequestToShowGmailOtpOptInDialog:
            return "Receive glic::mojom::ActorClient::RequestToShowGmailOtpOptInDialog";
      case messages::ActorClient::kRequestToShowGmailOtpConfirmationDialog:
            return "Receive glic::mojom::ActorClient::RequestToShowGmailOtpConfirmationDialog";
    }
  } else {
    switch (static_cast<messages::ActorClient>(message.name())) {
      case messages::ActorClient::kRequestToShowCredentialSelectionDialog:
            return "Receive reply glic::mojom::ActorClient::RequestToShowCredentialSelectionDialog";
      case messages::ActorClient::kRequestToShowAutofillSuggestionsDialog:
            return "Receive reply glic::mojom::ActorClient::RequestToShowAutofillSuggestionsDialog";
      case messages::ActorClient::kRequestToShowUserConfirmationDialog:
            return "Receive reply glic::mojom::ActorClient::RequestToShowUserConfirmationDialog";
      case messages::ActorClient::kRequestToConfirmNavigation:
            return "Receive reply glic::mojom::ActorClient::RequestToConfirmNavigation";
      case messages::ActorClient::kNotifyActorTaskStateChanged:
            return "Receive reply glic::mojom::ActorClient::NotifyActorTaskStateChanged";
      case messages::ActorClient::kRequestToShowGmailOtpOptInDialog:
            return "Receive reply glic::mojom::ActorClient::RequestToShowGmailOtpOptInDialog";
      case messages::ActorClient::kRequestToShowGmailOtpConfirmationDialog:
            return "Receive reply glic::mojom::ActorClient::RequestToShowGmailOtpConfirmationDialog";
    }
  }
  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 ActorClient::RequestToShowCredentialSelectionDialog_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 = 0x0a4001e1;  // IPCStableHash for glic::mojom::ActorClient::RequestToShowCredentialSelectionDialog
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorClient::RequestToShowAutofillSuggestionsDialog_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 = 0x27728add;  // IPCStableHash for glic::mojom::ActorClient::RequestToShowAutofillSuggestionsDialog
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorClient::RequestToShowUserConfirmationDialog_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 = 0x41527c95;  // IPCStableHash for glic::mojom::ActorClient::RequestToShowUserConfirmationDialog
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorClient::RequestToConfirmNavigation_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 = 0x02791900;  // IPCStableHash for glic::mojom::ActorClient::RequestToConfirmNavigation
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorClient::NotifyActorTaskStateChanged_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 = 0x93a8b476;  // IPCStableHash for glic::mojom::ActorClient::NotifyActorTaskStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorClient::RequestToShowGmailOtpOptInDialog_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 = 0x150239bf;  // IPCStableHash for glic::mojom::ActorClient::RequestToShowGmailOtpOptInDialog
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorClient::RequestToShowGmailOtpConfirmationDialog_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 = 0x9bb342f9;  // IPCStableHash for glic::mojom::ActorClient::RequestToShowGmailOtpConfirmationDialog
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ActorClient_RequestToShowCredentialSelectionDialog_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorClient_RequestToShowCredentialSelectionDialog_ForwardToCallback(
      ActorClient::RequestToShowCredentialSelectionDialogCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorClient::RequestToShowCredentialSelectionDialogCallback callback_;
};

class ActorClient_RequestToShowAutofillSuggestionsDialog_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorClient_RequestToShowAutofillSuggestionsDialog_ForwardToCallback(
      ActorClient::RequestToShowAutofillSuggestionsDialogCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorClient::RequestToShowAutofillSuggestionsDialogCallback callback_;
};

class ActorClient_RequestToShowUserConfirmationDialog_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorClient_RequestToShowUserConfirmationDialog_ForwardToCallback(
      ActorClient::RequestToShowUserConfirmationDialogCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorClient::RequestToShowUserConfirmationDialogCallback callback_;
};

class ActorClient_RequestToConfirmNavigation_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorClient_RequestToConfirmNavigation_ForwardToCallback(
      ActorClient::RequestToConfirmNavigationCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorClient::RequestToConfirmNavigationCallback callback_;
};

class ActorClient_RequestToShowGmailOtpOptInDialog_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorClient_RequestToShowGmailOtpOptInDialog_ForwardToCallback(
      ActorClient::RequestToShowGmailOtpOptInDialogCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorClient::RequestToShowGmailOtpOptInDialogCallback callback_;
};

class ActorClient_RequestToShowGmailOtpConfirmationDialog_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorClient_RequestToShowGmailOtpConfirmationDialog_ForwardToCallback(
      ActorClient::RequestToShowGmailOtpConfirmationDialogCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorClient::RequestToShowGmailOtpConfirmationDialogCallback callback_;
};

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

void ActorClientProxy::RequestToShowCredentialSelectionDialog(
    ::actor::webui::mojom::SelectCredentialDialogRequestPtr in_request, RequestToShowCredentialSelectionDialogCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::RequestToShowCredentialSelectionDialog", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type ::actor::webui::mojom::SelectCredentialDialogRequestPtr>");
   });
#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::ActorClient::kRequestToShowCredentialSelectionDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowCredentialSelectionDialog_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::SelectCredentialDialogRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void ActorClientProxy::RequestToShowAutofillSuggestionsDialog(
    ::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr in_request, RequestToShowAutofillSuggestionsDialogCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::RequestToShowAutofillSuggestionsDialog", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type ::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr>");
   });
#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::ActorClient::kRequestToShowAutofillSuggestionsDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void ActorClientProxy::RequestToShowUserConfirmationDialog(
    ::actor::webui::mojom::UserConfirmationDialogRequestPtr in_request, RequestToShowUserConfirmationDialogCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::RequestToShowUserConfirmationDialog", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type ::actor::webui::mojom::UserConfirmationDialogRequestPtr>");
   });
#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::ActorClient::kRequestToShowUserConfirmationDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowUserConfirmationDialog_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::UserConfirmationDialogRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void ActorClientProxy::RequestToConfirmNavigation(
    ::actor::webui::mojom::NavigationConfirmationRequestPtr in_request, RequestToConfirmNavigationCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::RequestToConfirmNavigation", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type ::actor::webui::mojom::NavigationConfirmationRequestPtr>");
   });
#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::ActorClient::kRequestToConfirmNavigation), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToConfirmNavigation_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::NavigationConfirmationRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void ActorClientProxy::NotifyActorTaskStateChanged(
    int32_t in_task_id, ActorTaskState in_state) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::NotifyActorTaskStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("state"), in_state,
                        "<value of type ActorTaskState>");
   });
#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::ActorClient::kNotifyActorTaskStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_NotifyActorTaskStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

  
  mojo::internal::Serialize<::glic::mojom::ActorTaskState>(
    in_state,
    &params->state);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("NotifyActorTaskStateChanged");
#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 ActorClientProxy::RequestToShowGmailOtpOptInDialog(
    ::actor::webui::mojom::GmailOtpOptInRequestPtr in_request, RequestToShowGmailOtpOptInDialogCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::RequestToShowGmailOtpOptInDialog", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type ::actor::webui::mojom::GmailOtpOptInRequestPtr>");
   });
#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::ActorClient::kRequestToShowGmailOtpOptInDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::GmailOtpOptInRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void ActorClientProxy::RequestToShowGmailOtpConfirmationDialog(
    ::actor::webui::mojom::GmailOtpConfirmationRequestPtr in_request, RequestToShowGmailOtpConfirmationDialogCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorClient::RequestToShowGmailOtpConfirmationDialog", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type ::actor::webui::mojom::GmailOtpConfirmationRequestPtr>");
   });
#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::ActorClient::kRequestToShowGmailOtpConfirmationDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::GmailOtpConfirmationRequestDataView>(
    in_request,
    request_fragment);

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

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

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

  ~ActorClient_RequestToShowCredentialSelectionDialog_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:
  ActorClient_RequestToShowCredentialSelectionDialog_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)
        << "ActorClient::RequestToShowCredentialSelectionDialogCallback 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(
      ::actor::webui::mojom::SelectCredentialDialogResponsePtr in_response);
};

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

  // Validation for ActorClient.0
  bool success = true;
  ::actor::webui::mojom::SelectCredentialDialogResponsePtr p_response{};
  ActorClient_RequestToShowCredentialSelectionDialog_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResponse(&p_response))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorClient::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_response));
  }
  return true;
}

void ActorClient_RequestToShowCredentialSelectionDialog_ProxyToResponder::Run(
    ::actor::webui::mojom::SelectCredentialDialogResponsePtr in_response) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorClient::RequestToShowCredentialSelectionDialog", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("response"), in_response,
                        "<value of type ::actor::webui::mojom::SelectCredentialDialogResponsePtr>");
   });
#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::ActorClient::kRequestToShowCredentialSelectionDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->response)::BaseType> response_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::SelectCredentialDialogResponseDataView>(
    in_response,
    response_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("RequestToShowCredentialSelectionDialog");
#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 ActorClient_RequestToShowAutofillSuggestionsDialog_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorClient::RequestToShowAutofillSuggestionsDialogCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorClient_RequestToShowAutofillSuggestionsDialog_ProxyToResponder> proxy(
        new ActorClient_RequestToShowAutofillSuggestionsDialog_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorClient_RequestToShowAutofillSuggestionsDialog_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorClient_RequestToShowAutofillSuggestionsDialog_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:
  ActorClient_RequestToShowAutofillSuggestionsDialog_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)
        << "ActorClient::RequestToShowAutofillSuggestionsDialogCallback 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(
      ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr in_response);
};

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

  // Validation for ActorClient.1
  bool success = true;
  ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr p_response{};
  ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResponse(&p_response))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorClient::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_response));
  }
  return true;
}

void ActorClient_RequestToShowAutofillSuggestionsDialog_ProxyToResponder::Run(
    ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr in_response) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorClient::RequestToShowAutofillSuggestionsDialog", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("response"), in_response,
                        "<value of type ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr>");
   });
#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::ActorClient::kRequestToShowAutofillSuggestionsDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->response)::BaseType> response_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::SelectAutofillSuggestionsDialogResponseDataView>(
    in_response,
    response_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("RequestToShowAutofillSuggestionsDialog");
#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 ActorClient_RequestToShowUserConfirmationDialog_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorClient::RequestToShowUserConfirmationDialogCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorClient_RequestToShowUserConfirmationDialog_ProxyToResponder> proxy(
        new ActorClient_RequestToShowUserConfirmationDialog_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorClient_RequestToShowUserConfirmationDialog_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorClient_RequestToShowUserConfirmationDialog_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:
  ActorClient_RequestToShowUserConfirmationDialog_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)
        << "ActorClient::RequestToShowUserConfirmationDialogCallback 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(
      ::actor::webui::mojom::UserConfirmationDialogResponsePtr in_response);
};

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

  // Validation for ActorClient.2
  bool success = true;
  ::actor::webui::mojom::UserConfirmationDialogResponsePtr p_response{};
  ActorClient_RequestToShowUserConfirmationDialog_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResponse(&p_response))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorClient::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_response));
  }
  return true;
}

void ActorClient_RequestToShowUserConfirmationDialog_ProxyToResponder::Run(
    ::actor::webui::mojom::UserConfirmationDialogResponsePtr in_response) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorClient::RequestToShowUserConfirmationDialog", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("response"), in_response,
                        "<value of type ::actor::webui::mojom::UserConfirmationDialogResponsePtr>");
   });
#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::ActorClient::kRequestToShowUserConfirmationDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->response)::BaseType> response_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::UserConfirmationDialogResponseDataView>(
    in_response,
    response_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("RequestToShowUserConfirmationDialog");
#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 ActorClient_RequestToConfirmNavigation_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorClient::RequestToConfirmNavigationCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorClient_RequestToConfirmNavigation_ProxyToResponder> proxy(
        new ActorClient_RequestToConfirmNavigation_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorClient_RequestToConfirmNavigation_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorClient_RequestToConfirmNavigation_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:
  ActorClient_RequestToConfirmNavigation_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)
        << "ActorClient::RequestToConfirmNavigationCallback 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(
      ::actor::webui::mojom::NavigationConfirmationResponsePtr in_response);
};

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

  // Validation for ActorClient.3
  bool success = true;
  ::actor::webui::mojom::NavigationConfirmationResponsePtr p_response{};
  ActorClient_RequestToConfirmNavigation_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResponse(&p_response))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorClient::Name_, 3, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_response));
  }
  return true;
}

void ActorClient_RequestToConfirmNavigation_ProxyToResponder::Run(
    ::actor::webui::mojom::NavigationConfirmationResponsePtr in_response) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorClient::RequestToConfirmNavigation", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("response"), in_response,
                        "<value of type ::actor::webui::mojom::NavigationConfirmationResponsePtr>");
   });
#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::ActorClient::kRequestToConfirmNavigation), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToConfirmNavigation_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->response)::BaseType> response_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::NavigationConfirmationResponseDataView>(
    in_response,
    response_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("RequestToConfirmNavigation");
#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 ActorClient_RequestToShowGmailOtpOptInDialog_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorClient::RequestToShowGmailOtpOptInDialogCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorClient_RequestToShowGmailOtpOptInDialog_ProxyToResponder> proxy(
        new ActorClient_RequestToShowGmailOtpOptInDialog_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorClient_RequestToShowGmailOtpOptInDialog_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorClient_RequestToShowGmailOtpOptInDialog_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:
  ActorClient_RequestToShowGmailOtpOptInDialog_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)
        << "ActorClient::RequestToShowGmailOtpOptInDialogCallback 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(
      ::actor::webui::mojom::GmailOtpOptInResultPtr in_result);
};

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

  // Validation for ActorClient.5
  bool success = true;
  ::actor::webui::mojom::GmailOtpOptInResultPtr p_result{};
  ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorClient::Name_, 5, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void ActorClient_RequestToShowGmailOtpOptInDialog_ProxyToResponder::Run(
    ::actor::webui::mojom::GmailOtpOptInResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorClient::RequestToShowGmailOtpOptInDialog", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type ::actor::webui::mojom::GmailOtpOptInResultPtr>");
   });
#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::ActorClient::kRequestToShowGmailOtpOptInDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::actor::webui::mojom::GmailOtpOptInResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("RequestToShowGmailOtpOptInDialog");
#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 ActorClient_RequestToShowGmailOtpConfirmationDialog_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorClient::RequestToShowGmailOtpConfirmationDialogCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorClient_RequestToShowGmailOtpConfirmationDialog_ProxyToResponder> proxy(
        new ActorClient_RequestToShowGmailOtpConfirmationDialog_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorClient_RequestToShowGmailOtpConfirmationDialog_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorClient_RequestToShowGmailOtpConfirmationDialog_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:
  ActorClient_RequestToShowGmailOtpConfirmationDialog_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)
        << "ActorClient::RequestToShowGmailOtpConfirmationDialogCallback 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(
      ::actor::webui::mojom::GmailOtpConfirmationResultPtr in_result);
};

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

  // Validation for ActorClient.6
  bool success = true;
  ::actor::webui::mojom::GmailOtpConfirmationResultPtr p_result{};
  ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorClient::Name_, 6, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void ActorClient_RequestToShowGmailOtpConfirmationDialog_ProxyToResponder::Run(
    ::actor::webui::mojom::GmailOtpConfirmationResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorClient::RequestToShowGmailOtpConfirmationDialog", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type ::actor::webui::mojom::GmailOtpConfirmationResultPtr>");
   });
#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::ActorClient::kRequestToShowGmailOtpConfirmationDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::actor::webui::mojom::GmailOtpConfirmationResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorClient::Name_);
  message.set_method_name("RequestToShowGmailOtpConfirmationDialog");
#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 ActorClientStubDispatch::Accept(
    ActorClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ActorClient>(message->header()->name)) {
    case messages::ActorClient::kRequestToShowCredentialSelectionDialog: {
      break;
    }
    case messages::ActorClient::kRequestToShowAutofillSuggestionsDialog: {
      break;
    }
    case messages::ActorClient::kRequestToShowUserConfirmationDialog: {
      break;
    }
    case messages::ActorClient::kRequestToConfirmNavigation: {
      break;
    }
    case messages::ActorClient::kNotifyActorTaskStateChanged: {
      DCHECK(message->is_serialized());
      internal::ActorClient_NotifyActorTaskStateChanged_Params_Data* params =
          reinterpret_cast<internal::ActorClient_NotifyActorTaskStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorClient.4
      bool success = true;
      int32_t p_task_id{};
      ActorTaskState p_state{};
      ActorClient_NotifyActorTaskStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadState(&p_state))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyActorTaskStateChanged(        
        std::move(p_task_id), 
        std::move(p_state));
      return true;
    }
    case messages::ActorClient::kRequestToShowGmailOtpOptInDialog: {
      break;
    }
    case messages::ActorClient::kRequestToShowGmailOtpConfirmationDialog: {
      break;
    }
  }
  return false;
}

// static
bool ActorClientStubDispatch::AcceptWithResponder(
    ActorClient* 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::ActorClient>(message->header()->name)) {
    case messages::ActorClient::kRequestToShowCredentialSelectionDialog: {
      internal::ActorClient_RequestToShowCredentialSelectionDialog_Params_Data* params =
          reinterpret_cast<
              internal::ActorClient_RequestToShowCredentialSelectionDialog_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorClient.0
      bool success = true;
      ::actor::webui::mojom::SelectCredentialDialogRequestPtr p_request{};
      ActorClient_RequestToShowCredentialSelectionDialog_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 0, false);
        return false;
      }
      auto callback =
          ActorClient_RequestToShowCredentialSelectionDialog_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestToShowCredentialSelectionDialog(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::ActorClient::kRequestToShowAutofillSuggestionsDialog: {
      internal::ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data* params =
          reinterpret_cast<
              internal::ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorClient.1
      bool success = true;
      ::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr p_request{};
      ActorClient_RequestToShowAutofillSuggestionsDialog_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 1, false);
        return false;
      }
      auto callback =
          ActorClient_RequestToShowAutofillSuggestionsDialog_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestToShowAutofillSuggestionsDialog(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::ActorClient::kRequestToShowUserConfirmationDialog: {
      internal::ActorClient_RequestToShowUserConfirmationDialog_Params_Data* params =
          reinterpret_cast<
              internal::ActorClient_RequestToShowUserConfirmationDialog_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorClient.2
      bool success = true;
      ::actor::webui::mojom::UserConfirmationDialogRequestPtr p_request{};
      ActorClient_RequestToShowUserConfirmationDialog_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 2, false);
        return false;
      }
      auto callback =
          ActorClient_RequestToShowUserConfirmationDialog_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestToShowUserConfirmationDialog(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::ActorClient::kRequestToConfirmNavigation: {
      internal::ActorClient_RequestToConfirmNavigation_Params_Data* params =
          reinterpret_cast<
              internal::ActorClient_RequestToConfirmNavigation_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorClient.3
      bool success = true;
      ::actor::webui::mojom::NavigationConfirmationRequestPtr p_request{};
      ActorClient_RequestToConfirmNavigation_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 3, false);
        return false;
      }
      auto callback =
          ActorClient_RequestToConfirmNavigation_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestToConfirmNavigation(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::ActorClient::kNotifyActorTaskStateChanged: {
      break;
    }
    case messages::ActorClient::kRequestToShowGmailOtpOptInDialog: {
      internal::ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data* params =
          reinterpret_cast<
              internal::ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorClient.5
      bool success = true;
      ::actor::webui::mojom::GmailOtpOptInRequestPtr p_request{};
      ActorClient_RequestToShowGmailOtpOptInDialog_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 5, false);
        return false;
      }
      auto callback =
          ActorClient_RequestToShowGmailOtpOptInDialog_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestToShowGmailOtpOptInDialog(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::ActorClient::kRequestToShowGmailOtpConfirmationDialog: {
      internal::ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data* params =
          reinterpret_cast<
              internal::ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorClient.6
      bool success = true;
      ::actor::webui::mojom::GmailOtpConfirmationRequestPtr p_request{};
      ActorClient_RequestToShowGmailOtpConfirmationDialog_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorClient::Name_, 6, false);
        return false;
      }
      auto callback =
          ActorClient_RequestToShowGmailOtpConfirmationDialog_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestToShowGmailOtpConfirmationDialog(        
        std::move(p_request), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kActorClientValidationInfo[] = {
    { &internal::ActorClient_RequestToShowCredentialSelectionDialog_Params_Data::Validate,
     &internal::ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data::Validate},
    { &internal::ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data::Validate,
     &internal::ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data::Validate},
    { &internal::ActorClient_RequestToShowUserConfirmationDialog_Params_Data::Validate,
     &internal::ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data::Validate},
    { &internal::ActorClient_RequestToConfirmNavigation_Params_Data::Validate,
     &internal::ActorClient_RequestToConfirmNavigation_ResponseParams_Data::Validate},
    { &internal::ActorClient_NotifyActorTaskStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data::Validate,
     &internal::ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data::Validate},
    { &internal::ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data::Validate,
     &internal::ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data::Validate},
};

bool ActorClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::ActorClient::Name_,
    kActorClientValidationInfo);
}

bool ActorClientResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::ActorClient::Name_,
    kActorClientValidationInfo);
}
// The declaration includes the definition on other builds.

ActorHandler::IPCStableHashFunction ActorHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ActorHandler>(message.name())) {
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormPresented: {
      return &ActorHandler::AutofillSuggestionDialogOnFormPresented_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormPreviewChanged: {
      return &ActorHandler::AutofillSuggestionDialogOnFormPreviewChanged_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormConfirmed: {
      return &ActorHandler::AutofillSuggestionDialogOnFormConfirmed_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kGetContextForActorFromTab: {
      return &ActorHandler::GetContextForActorFromTab_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kCreateTask: {
      return &ActorHandler::CreateTask_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kPerformActions: {
      return &ActorHandler::PerformActions_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kCancelActions: {
      return &ActorHandler::CancelActions_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kStopActorTask: {
      return &ActorHandler::StopActorTask_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kPauseActorTask: {
      return &ActorHandler::PauseActorTask_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kResumeActorTask: {
      return &ActorHandler::ResumeActorTask_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kInterruptActorTask: {
      return &ActorHandler::InterruptActorTask_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kUninterruptActorTask: {
      return &ActorHandler::UninterruptActorTask_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kUpdateActorTaskStepProgress: {
      return &ActorHandler::UpdateActorTaskStepProgress_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kCreateActorTab: {
      return &ActorHandler::CreateActorTab_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kLogBeginAsyncEvent: {
      return &ActorHandler::LogBeginAsyncEvent_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kLogEndAsyncEvent: {
      return &ActorHandler::LogEndAsyncEvent_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kLogInstantEvent: {
      return &ActorHandler::LogInstantEvent_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kJournalClear: {
      return &ActorHandler::JournalClear_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kJournalSnapshot: {
      return &ActorHandler::JournalSnapshot_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kJournalStart: {
      return &ActorHandler::JournalStart_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kJournalStop: {
      return &ActorHandler::JournalStop_Sym::IPCStableHash;
    }
    case messages::ActorHandler::kJournalRecordFeedback: {
      return &ActorHandler::JournalRecordFeedback_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ActorHandler::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::ActorHandler>(message.name())) {
      case messages::ActorHandler::kAutofillSuggestionDialogOnFormPresented:
            return "Receive glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPresented";
      case messages::ActorHandler::kAutofillSuggestionDialogOnFormPreviewChanged:
            return "Receive glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPreviewChanged";
      case messages::ActorHandler::kAutofillSuggestionDialogOnFormConfirmed:
            return "Receive glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormConfirmed";
      case messages::ActorHandler::kGetContextForActorFromTab:
            return "Receive glic::mojom::ActorHandler::GetContextForActorFromTab";
      case messages::ActorHandler::kCreateTask:
            return "Receive glic::mojom::ActorHandler::CreateTask";
      case messages::ActorHandler::kPerformActions:
            return "Receive glic::mojom::ActorHandler::PerformActions";
      case messages::ActorHandler::kCancelActions:
            return "Receive glic::mojom::ActorHandler::CancelActions";
      case messages::ActorHandler::kStopActorTask:
            return "Receive glic::mojom::ActorHandler::StopActorTask";
      case messages::ActorHandler::kPauseActorTask:
            return "Receive glic::mojom::ActorHandler::PauseActorTask";
      case messages::ActorHandler::kResumeActorTask:
            return "Receive glic::mojom::ActorHandler::ResumeActorTask";
      case messages::ActorHandler::kInterruptActorTask:
            return "Receive glic::mojom::ActorHandler::InterruptActorTask";
      case messages::ActorHandler::kUninterruptActorTask:
            return "Receive glic::mojom::ActorHandler::UninterruptActorTask";
      case messages::ActorHandler::kUpdateActorTaskStepProgress:
            return "Receive glic::mojom::ActorHandler::UpdateActorTaskStepProgress";
      case messages::ActorHandler::kCreateActorTab:
            return "Receive glic::mojom::ActorHandler::CreateActorTab";
      case messages::ActorHandler::kLogBeginAsyncEvent:
            return "Receive glic::mojom::ActorHandler::LogBeginAsyncEvent";
      case messages::ActorHandler::kLogEndAsyncEvent:
            return "Receive glic::mojom::ActorHandler::LogEndAsyncEvent";
      case messages::ActorHandler::kLogInstantEvent:
            return "Receive glic::mojom::ActorHandler::LogInstantEvent";
      case messages::ActorHandler::kJournalClear:
            return "Receive glic::mojom::ActorHandler::JournalClear";
      case messages::ActorHandler::kJournalSnapshot:
            return "Receive glic::mojom::ActorHandler::JournalSnapshot";
      case messages::ActorHandler::kJournalStart:
            return "Receive glic::mojom::ActorHandler::JournalStart";
      case messages::ActorHandler::kJournalStop:
            return "Receive glic::mojom::ActorHandler::JournalStop";
      case messages::ActorHandler::kJournalRecordFeedback:
            return "Receive glic::mojom::ActorHandler::JournalRecordFeedback";
    }
  } else {
    switch (static_cast<messages::ActorHandler>(message.name())) {
      case messages::ActorHandler::kAutofillSuggestionDialogOnFormPresented:
            return "Receive reply glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPresented";
      case messages::ActorHandler::kAutofillSuggestionDialogOnFormPreviewChanged:
            return "Receive reply glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPreviewChanged";
      case messages::ActorHandler::kAutofillSuggestionDialogOnFormConfirmed:
            return "Receive reply glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormConfirmed";
      case messages::ActorHandler::kGetContextForActorFromTab:
            return "Receive reply glic::mojom::ActorHandler::GetContextForActorFromTab";
      case messages::ActorHandler::kCreateTask:
            return "Receive reply glic::mojom::ActorHandler::CreateTask";
      case messages::ActorHandler::kPerformActions:
            return "Receive reply glic::mojom::ActorHandler::PerformActions";
      case messages::ActorHandler::kCancelActions:
            return "Receive reply glic::mojom::ActorHandler::CancelActions";
      case messages::ActorHandler::kStopActorTask:
            return "Receive reply glic::mojom::ActorHandler::StopActorTask";
      case messages::ActorHandler::kPauseActorTask:
            return "Receive reply glic::mojom::ActorHandler::PauseActorTask";
      case messages::ActorHandler::kResumeActorTask:
            return "Receive reply glic::mojom::ActorHandler::ResumeActorTask";
      case messages::ActorHandler::kInterruptActorTask:
            return "Receive reply glic::mojom::ActorHandler::InterruptActorTask";
      case messages::ActorHandler::kUninterruptActorTask:
            return "Receive reply glic::mojom::ActorHandler::UninterruptActorTask";
      case messages::ActorHandler::kUpdateActorTaskStepProgress:
            return "Receive reply glic::mojom::ActorHandler::UpdateActorTaskStepProgress";
      case messages::ActorHandler::kCreateActorTab:
            return "Receive reply glic::mojom::ActorHandler::CreateActorTab";
      case messages::ActorHandler::kLogBeginAsyncEvent:
            return "Receive reply glic::mojom::ActorHandler::LogBeginAsyncEvent";
      case messages::ActorHandler::kLogEndAsyncEvent:
            return "Receive reply glic::mojom::ActorHandler::LogEndAsyncEvent";
      case messages::ActorHandler::kLogInstantEvent:
            return "Receive reply glic::mojom::ActorHandler::LogInstantEvent";
      case messages::ActorHandler::kJournalClear:
            return "Receive reply glic::mojom::ActorHandler::JournalClear";
      case messages::ActorHandler::kJournalSnapshot:
            return "Receive reply glic::mojom::ActorHandler::JournalSnapshot";
      case messages::ActorHandler::kJournalStart:
            return "Receive reply glic::mojom::ActorHandler::JournalStart";
      case messages::ActorHandler::kJournalStop:
            return "Receive reply glic::mojom::ActorHandler::JournalStop";
      case messages::ActorHandler::kJournalRecordFeedback:
            return "Receive reply glic::mojom::ActorHandler::JournalRecordFeedback";
    }
  }
  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 ActorHandler::AutofillSuggestionDialogOnFormPresented_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 = 0xd11e3d66;  // IPCStableHash for glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPresented
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::AutofillSuggestionDialogOnFormPreviewChanged_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 = 0xf05f5f78;  // IPCStableHash for glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPreviewChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::AutofillSuggestionDialogOnFormConfirmed_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 = 0xe0b5b2fb;  // IPCStableHash for glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormConfirmed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::GetContextForActorFromTab_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 = 0x26c9d33d;  // IPCStableHash for glic::mojom::ActorHandler::GetContextForActorFromTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::CreateTask_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 = 0x174e498a;  // IPCStableHash for glic::mojom::ActorHandler::CreateTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::PerformActions_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 = 0x920165b0;  // IPCStableHash for glic::mojom::ActorHandler::PerformActions
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::CancelActions_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 = 0xc931ec14;  // IPCStableHash for glic::mojom::ActorHandler::CancelActions
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::StopActorTask_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 = 0x1260021d;  // IPCStableHash for glic::mojom::ActorHandler::StopActorTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::PauseActorTask_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 = 0xee893ad6;  // IPCStableHash for glic::mojom::ActorHandler::PauseActorTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::ResumeActorTask_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 = 0xdff8f5a8;  // IPCStableHash for glic::mojom::ActorHandler::ResumeActorTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::InterruptActorTask_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 = 0x0462c9ef;  // IPCStableHash for glic::mojom::ActorHandler::InterruptActorTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::UninterruptActorTask_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 = 0xebbc0407;  // IPCStableHash for glic::mojom::ActorHandler::UninterruptActorTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::UpdateActorTaskStepProgress_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 = 0x420d445c;  // IPCStableHash for glic::mojom::ActorHandler::UpdateActorTaskStepProgress
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::CreateActorTab_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 = 0x3f8adcfa;  // IPCStableHash for glic::mojom::ActorHandler::CreateActorTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::LogBeginAsyncEvent_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 = 0xd63c7dbe;  // IPCStableHash for glic::mojom::ActorHandler::LogBeginAsyncEvent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::LogEndAsyncEvent_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 = 0x1add1e2d;  // IPCStableHash for glic::mojom::ActorHandler::LogEndAsyncEvent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::LogInstantEvent_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 = 0x82ee7c94;  // IPCStableHash for glic::mojom::ActorHandler::LogInstantEvent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::JournalClear_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 = 0xd9c3f1b5;  // IPCStableHash for glic::mojom::ActorHandler::JournalClear
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::JournalSnapshot_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 = 0xe40246a6;  // IPCStableHash for glic::mojom::ActorHandler::JournalSnapshot
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::JournalStart_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 = 0x2646787a;  // IPCStableHash for glic::mojom::ActorHandler::JournalStart
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::JournalStop_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 = 0x570367be;  // IPCStableHash for glic::mojom::ActorHandler::JournalStop
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ActorHandler::JournalRecordFeedback_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 = 0x895f6a9b;  // IPCStableHash for glic::mojom::ActorHandler::JournalRecordFeedback
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ActorHandler_GetContextForActorFromTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_GetContextForActorFromTab_ForwardToCallback(
      ActorHandler::GetContextForActorFromTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::GetContextForActorFromTabCallback callback_;
};

class ActorHandler_CreateTask_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_CreateTask_ForwardToCallback(
      ActorHandler::CreateTaskCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::CreateTaskCallback callback_;
};

class ActorHandler_PerformActions_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_PerformActions_ForwardToCallback(
      ActorHandler::PerformActionsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::PerformActionsCallback callback_;
};

class ActorHandler_CancelActions_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_CancelActions_ForwardToCallback(
      ActorHandler::CancelActionsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::CancelActionsCallback callback_;
};

class ActorHandler_ResumeActorTask_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_ResumeActorTask_ForwardToCallback(
      ActorHandler::ResumeActorTaskCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::ResumeActorTaskCallback callback_;
};

class ActorHandler_CreateActorTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_CreateActorTab_ForwardToCallback(
      ActorHandler::CreateActorTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::CreateActorTabCallback callback_;
};

class ActorHandler_JournalSnapshot_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ActorHandler_JournalSnapshot_ForwardToCallback(
      ActorHandler::JournalSnapshotCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ActorHandler::JournalSnapshotCallback callback_;
};

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

void ActorHandlerProxy::AutofillSuggestionDialogOnFormPresented(
    int32_t in_task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsPtr in_params) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPresented", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type ::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsPtr>");
   });
#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::ActorHandler::kAutofillSuggestionDialogOnFormPresented), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType> params_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsDataView>(
    in_params,
    params_fragment);

  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 ActorHandler.AutofillSuggestionDialogOnFormPresented request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("AutofillSuggestionDialogOnFormPresented");
#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 ActorHandlerProxy::AutofillSuggestionDialogOnFormPreviewChanged(
    int32_t in_task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsPtr in_params) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormPreviewChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type ::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsPtr>");
   });
#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::ActorHandler::kAutofillSuggestionDialogOnFormPreviewChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType> params_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsDataView>(
    in_params,
    params_fragment);

  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 ActorHandler.AutofillSuggestionDialogOnFormPreviewChanged request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("AutofillSuggestionDialogOnFormPreviewChanged");
#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 ActorHandlerProxy::AutofillSuggestionDialogOnFormConfirmed(
    int32_t in_task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsPtr in_params) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::AutofillSuggestionDialogOnFormConfirmed", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type ::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsPtr>");
   });
#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::ActorHandler::kAutofillSuggestionDialogOnFormConfirmed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType> params_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsDataView>(
    in_params,
    params_fragment);

  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 ActorHandler.AutofillSuggestionDialogOnFormConfirmed request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("AutofillSuggestionDialogOnFormConfirmed");
#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 ActorHandlerProxy::GetContextForActorFromTab(
    int32_t in_tab_id, TabContextOptionsPtr in_options, GetContextForActorFromTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::GetContextForActorFromTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type TabContextOptionsPtr>");
   });
#endif

  CHECK(base::FeatureList::IsEnabled(::glic::mojom::features::kGlicActorTabContext));
  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::ActorHandler::kGetContextForActorFromTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_GetContextForActorFromTab_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabContextOptionsDataView>(
    in_options,
    options_fragment);

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

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

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

void ActorHandlerProxy::CreateTask(
    ::actor::webui::mojom::TaskOptionsPtr in_task_options, CreateTaskCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::CreateTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_options"), in_task_options,
                        "<value of type ::actor::webui::mojom::TaskOptionsPtr>");
   });
#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::ActorHandler::kCreateTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_CreateTask_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->task_options)::BaseType> task_options_fragment(
          params.message());
  
  mojo::internal::Serialize<::actor::webui::mojom::TaskOptionsDataView>(
    in_task_options,
    task_options_fragment);

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

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

void ActorHandlerProxy::PerformActions(
    const std::vector<uint8_t>& in_actions_proto, PerformActionsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::PerformActions", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("actions_proto"), in_actions_proto,
                        "<value of type const std::vector<uint8_t>&>");
   });
#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::ActorHandler::kPerformActions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_PerformActions_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->actions_proto)::BaseType>
      actions_proto_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& actions_proto_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
    in_actions_proto,
    actions_proto_fragment,
    &actions_proto_validate_params);

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

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

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

void ActorHandlerProxy::CancelActions(
    int32_t in_task_id, CancelActionsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::CancelActions", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
   });
#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::ActorHandler::kCancelActions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_CancelActions_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

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

void ActorHandlerProxy::StopActorTask(
    int32_t in_task_id, ActorTaskStopReason in_stop_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::StopActorTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("stop_reason"), in_stop_reason,
                        "<value of type ActorTaskStopReason>");
   });
#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::ActorHandler::kStopActorTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_StopActorTask_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

  
  mojo::internal::Serialize<::glic::mojom::ActorTaskStopReason>(
    in_stop_reason,
    &params->stop_reason);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("StopActorTask");
#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 ActorHandlerProxy::PauseActorTask(
    int32_t in_task_id, ActorTaskPauseReason in_pause_reason, std::optional<int32_t> in_tab_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::PauseActorTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("pause_reason"), in_pause_reason,
                        "<value of type ActorTaskPauseReason>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type std::optional<int32_t>>");
   });
#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::ActorHandler::kPauseActorTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_PauseActorTask_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

  
  mojo::internal::Serialize<::glic::mojom::ActorTaskPauseReason>(
    in_pause_reason,
    &params->pause_reason);
  params->tab_id_$flag = in_tab_id.has_value();
  if (in_tab_id.has_value()) {
    params->tab_id_$value = in_tab_id.value();
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("PauseActorTask");
#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 ActorHandlerProxy::ResumeActorTask(
    int32_t in_task_id, TabContextOptionsPtr in_context_options, ResumeActorTaskCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::ResumeActorTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("context_options"), in_context_options,
                        "<value of type TabContextOptionsPtr>");
   });
#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::ActorHandler::kResumeActorTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_ResumeActorTask_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->context_options)::BaseType> context_options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabContextOptionsDataView>(
    in_context_options,
    context_options_fragment);

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

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

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

void ActorHandlerProxy::InterruptActorTask(
    int32_t in_task_id, std::optional<ActorTaskInterruptReason> in_interrupt_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::InterruptActorTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("interrupt_reason"), in_interrupt_reason,
                        "<value of type std::optional<ActorTaskInterruptReason>>");
   });
#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::ActorHandler::kInterruptActorTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_InterruptActorTask_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  params->interrupt_reason_$flag = in_interrupt_reason.has_value();
  if (in_interrupt_reason.has_value()) {
    
    mojo::internal::Serialize<::glic::mojom::ActorTaskInterruptReason>(
      in_interrupt_reason.value(),
      &params->interrupt_reason_$value);
  } else {
    params->interrupt_reason_$value =
        static_cast<int32_t>(::glic::mojom::ActorTaskInterruptReason::kMinValue);
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("InterruptActorTask");
#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 ActorHandlerProxy::UninterruptActorTask(
    int32_t in_task_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::UninterruptActorTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
   });
#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::ActorHandler::kUninterruptActorTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_UninterruptActorTask_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("UninterruptActorTask");
#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 ActorHandlerProxy::UpdateActorTaskStepProgress(
    int32_t in_task_id, const std::string& in_step_progress) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::UpdateActorTaskStepProgress", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("step_progress"), in_step_progress,
                        "<value of type const std::string&>");
   });
#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::ActorHandler::kUpdateActorTaskStepProgress), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_UpdateActorTaskStepProgress_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->step_progress)::BaseType> step_progress_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_step_progress,
    step_progress_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("UpdateActorTaskStepProgress");
#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 ActorHandlerProxy::CreateActorTab(
    int32_t in_task_id, CreateActorTabOptionsPtr in_options, CreateActorTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::CreateActorTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type CreateActorTabOptionsPtr>");
   });
#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::ActorHandler::kCreateActorTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_CreateActorTab_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::CreateActorTabOptionsDataView>(
    in_options,
    options_fragment);

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

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

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

void ActorHandlerProxy::LogBeginAsyncEvent(
    uint64_t in_event_async_id, int32_t in_task_id, const std::string& in_event, const std::string& in_details) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::LogBeginAsyncEvent", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("event_async_id"), in_event_async_id,
                        "<value of type uint64_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("event"), in_event,
                        "<value of type const std::string&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("details"), in_details,
                        "<value of type const std::string&>");
   });
#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::ActorHandler::kLogBeginAsyncEvent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_LogBeginAsyncEvent_Params_Data> params(
          message);
  params.Allocate();

  params->event_async_id = in_event_async_id;

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->event)::BaseType> event_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    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 ActorHandler.LogBeginAsyncEvent request");
  mojo::internal::MessageFragment<
      typename decltype(params->details)::BaseType> details_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_details,
    details_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("LogBeginAsyncEvent");
#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 ActorHandlerProxy::LogEndAsyncEvent(
    uint64_t in_event_async_id, const std::string& in_details) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::LogEndAsyncEvent", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("event_async_id"), in_event_async_id,
                        "<value of type uint64_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("details"), in_details,
                        "<value of type const std::string&>");
   });
#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::ActorHandler::kLogEndAsyncEvent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_LogEndAsyncEvent_Params_Data> params(
          message);
  params.Allocate();

  params->event_async_id = in_event_async_id;
  mojo::internal::MessageFragment<
      typename decltype(params->details)::BaseType> details_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_details,
    details_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("LogEndAsyncEvent");
#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 ActorHandlerProxy::LogInstantEvent(
    int32_t in_task_id, const std::string& in_event, const std::string& in_details) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::LogInstantEvent", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("event"), in_event,
                        "<value of type const std::string&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("details"), in_details,
                        "<value of type const std::string&>");
   });
#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::ActorHandler::kLogInstantEvent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_LogInstantEvent_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;
  mojo::internal::MessageFragment<
      typename decltype(params->event)::BaseType> event_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    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 ActorHandler.LogInstantEvent request");
  mojo::internal::MessageFragment<
      typename decltype(params->details)::BaseType> details_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_details,
    details_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("LogInstantEvent");
#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 ActorHandlerProxy::JournalClear(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::ActorHandler::JournalClear");
#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::ActorHandler::kJournalClear), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_JournalClear_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("JournalClear");
#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 ActorHandlerProxy::JournalSnapshot(
    bool in_clear_journal, JournalSnapshotCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::JournalSnapshot", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("clear_journal"), in_clear_journal,
                        "<value of type bool>");
   });
#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::ActorHandler::kJournalSnapshot), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_JournalSnapshot_Params_Data> params(
          message);
  params.Allocate();

  params->clear_journal = in_clear_journal;

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

void ActorHandlerProxy::JournalStart(
    uint64_t in_max_bytes, bool in_capture_screenshots) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::JournalStart", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("max_bytes"), in_max_bytes,
                        "<value of type uint64_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("capture_screenshots"), in_capture_screenshots,
                        "<value of type bool>");
   });
#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::ActorHandler::kJournalStart), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_JournalStart_Params_Data> params(
          message);
  params.Allocate();

  params->max_bytes = in_max_bytes;

  params->capture_screenshots = in_capture_screenshots;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("JournalStart");
#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 ActorHandlerProxy::JournalStop(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::ActorHandler::JournalStop");
#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::ActorHandler::kJournalStop), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_JournalStop_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("JournalStop");
#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 ActorHandlerProxy::JournalRecordFeedback(
    bool in_positive, const std::string& in_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ActorHandler::JournalRecordFeedback", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("positive"), in_positive,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("reason"), in_reason,
                        "<value of type const std::string&>");
   });
#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::ActorHandler::kJournalRecordFeedback), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_JournalRecordFeedback_Params_Data> params(
          message);
  params.Allocate();

  params->positive = in_positive;
  mojo::internal::MessageFragment<
      typename decltype(params->reason)::BaseType> reason_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_reason,
    reason_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("JournalRecordFeedback");
#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);
}
class ActorHandler_GetContextForActorFromTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::GetContextForActorFromTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_GetContextForActorFromTab_ProxyToResponder> proxy(
        new ActorHandler_GetContextForActorFromTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorHandler_GetContextForActorFromTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorHandler_GetContextForActorFromTab_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:
  ActorHandler_GetContextForActorFromTab_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)
        << "ActorHandler::GetContextForActorFromTabCallback 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(
      GetContextResultPtr in_result);
};

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

  // Validation for ActorHandler.3
  bool success = true;
  GetContextResultPtr p_result{};
  ActorHandler_GetContextForActorFromTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 3, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void ActorHandler_GetContextForActorFromTab_ProxyToResponder::Run(
    GetContextResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::GetContextForActorFromTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type GetContextResultPtr>");
   });
#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::ActorHandler::kGetContextForActorFromTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_GetContextForActorFromTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::GetContextResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("GetContextForActorFromTab");
#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 ActorHandler_CreateTask_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::CreateTaskCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_CreateTask_ProxyToResponder> proxy(
        new ActorHandler_CreateTask_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&ActorHandler_CreateTask_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static ActorHandler_CreateTask_ResponseParam_ResultPtr Transform(base::expected<
  int32_t,
  CreateTaskErrorReason> in) {
    return in.has_value() ? ::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~ActorHandler_CreateTask_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:
  ActorHandler_CreateTask_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)
        << "ActorHandler::CreateTaskCallback 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(
      ActorHandler_CreateTask_ResponseParam_ResultPtr in_result);
};

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

  // Validation for ActorHandler.4
  bool success = true;
  ActorHandler_CreateTask_ResponseParam_ResultPtr p_result{};
  ActorHandler_CreateTask_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 4, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void ActorHandler_CreateTask_ProxyToResponder::Run(
    ActorHandler_CreateTask_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::CreateTask", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type ActorHandler_CreateTask_ResponseParam_ResultPtr>");
   });
#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::ActorHandler::kCreateTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_CreateTask_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("CreateTask");
#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 ActorHandler_PerformActions_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::PerformActionsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_PerformActions_ProxyToResponder> proxy(
        new ActorHandler_PerformActions_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&ActorHandler_PerformActions_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static ActorHandler_PerformActions_ResponseParam_ResultPtr Transform(base::expected<
  ::mojo_base::ProtoWrapper,
  PerformActionsErrorReason> in) {
    return in.has_value() ? ::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~ActorHandler_PerformActions_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:
  ActorHandler_PerformActions_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)
        << "ActorHandler::PerformActionsCallback 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(
      ActorHandler_PerformActions_ResponseParam_ResultPtr in_result);
};

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

  // Validation for ActorHandler.5
  bool success = true;
  ActorHandler_PerformActions_ResponseParam_ResultPtr p_result{};
  ActorHandler_PerformActions_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 5, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void ActorHandler_PerformActions_ProxyToResponder::Run(
    ActorHandler_PerformActions_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::PerformActions", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type ActorHandler_PerformActions_ResponseParam_ResultPtr>");
   });
#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::ActorHandler::kPerformActions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_PerformActions_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("PerformActions");
#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 ActorHandler_CancelActions_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::CancelActionsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_CancelActions_ProxyToResponder> proxy(
        new ActorHandler_CancelActions_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorHandler_CancelActions_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorHandler_CancelActions_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:
  ActorHandler_CancelActions_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)
        << "ActorHandler::CancelActionsCallback 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(
      CancelActionsResult in_result);
};

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

  // Validation for ActorHandler.6
  bool success = true;
  CancelActionsResult p_result{};
  ActorHandler_CancelActions_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 6, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void ActorHandler_CancelActions_ProxyToResponder::Run(
    CancelActionsResult in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::CancelActions", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type CancelActionsResult>");
   });
#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::ActorHandler::kCancelActions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_CancelActions_ResponseParams_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::CancelActionsResult>(
    in_result,
    &params->result);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("CancelActions");
#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 ActorHandler_ResumeActorTask_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::ResumeActorTaskCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_ResumeActorTask_ProxyToResponder> proxy(
        new ActorHandler_ResumeActorTask_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorHandler_ResumeActorTask_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorHandler_ResumeActorTask_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:
  ActorHandler_ResumeActorTask_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)
        << "ActorHandler::ResumeActorTaskCallback 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(
      GetContextResultWithActionResultCodePtr in_result);
};

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

  // Validation for ActorHandler.9
  bool success = true;
  GetContextResultWithActionResultCodePtr p_result{};
  ActorHandler_ResumeActorTask_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 9, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void ActorHandler_ResumeActorTask_ProxyToResponder::Run(
    GetContextResultWithActionResultCodePtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::ResumeActorTask", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type GetContextResultWithActionResultCodePtr>");
   });
#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::ActorHandler::kResumeActorTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_ResumeActorTask_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->result)::BaseType> result_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::GetContextResultWithActionResultCodeDataView>(
    in_result,
    result_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("ResumeActorTask");
#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 ActorHandler_CreateActorTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::CreateActorTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_CreateActorTab_ProxyToResponder> proxy(
        new ActorHandler_CreateActorTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorHandler_CreateActorTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorHandler_CreateActorTab_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:
  ActorHandler_CreateActorTab_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)
        << "ActorHandler::CreateActorTabCallback 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(
      TabDataPtr in_tab_data);
};

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

  // Validation for ActorHandler.13
  bool success = true;
  TabDataPtr p_tab_data{};
  ActorHandler_CreateActorTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadTabData(&p_tab_data))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 13, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_tab_data));
  }
  return true;
}

void ActorHandler_CreateActorTab_ProxyToResponder::Run(
    TabDataPtr in_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::CreateActorTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_data"), in_tab_data,
                        "<value of type TabDataPtr>");
   });
#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::ActorHandler::kCreateActorTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_CreateActorTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_data)::BaseType> tab_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabDataDataView>(
    in_tab_data,
    tab_data_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("CreateActorTab");
#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 ActorHandler_JournalSnapshot_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ActorHandler::JournalSnapshotCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ActorHandler_JournalSnapshot_ProxyToResponder> proxy(
        new ActorHandler_JournalSnapshot_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ActorHandler_JournalSnapshot_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ActorHandler_JournalSnapshot_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:
  ActorHandler_JournalSnapshot_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)
        << "ActorHandler::JournalSnapshotCallback 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(
      JournalPtr in_journal);
};

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

  // Validation for ActorHandler.18
  bool success = true;
  JournalPtr p_journal{};
  ActorHandler_JournalSnapshot_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadJournal(&p_journal))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ActorHandler::Name_, 18, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_journal));
  }
  return true;
}

void ActorHandler_JournalSnapshot_ProxyToResponder::Run(
    JournalPtr in_journal) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ActorHandler::JournalSnapshot", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("journal"), in_journal,
                        "<value of type JournalPtr>");
   });
#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::ActorHandler::kJournalSnapshot), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ActorHandler_JournalSnapshot_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->journal)::BaseType> journal_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::JournalDataView>(
    in_journal,
    journal_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ActorHandler::Name_);
  message.set_method_name("JournalSnapshot");
#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 ActorHandlerStubDispatch::Accept(
    ActorHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ActorHandler>(message->header()->name)) {
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormPresented: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.0
      bool success = true;
      int32_t p_task_id{};
      ::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsPtr p_params{};
      ActorHandler_AutofillSuggestionDialogOnFormPresented_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AutofillSuggestionDialogOnFormPresented(        
        std::move(p_task_id), 
        std::move(p_params));
      return true;
    }
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormPreviewChanged: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.1
      bool success = true;
      int32_t p_task_id{};
      ::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsPtr p_params{};
      ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AutofillSuggestionDialogOnFormPreviewChanged(        
        std::move(p_task_id), 
        std::move(p_params));
      return true;
    }
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormConfirmed: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.2
      bool success = true;
      int32_t p_task_id{};
      ::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsPtr p_params{};
      ActorHandler_AutofillSuggestionDialogOnFormConfirmed_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AutofillSuggestionDialogOnFormConfirmed(        
        std::move(p_task_id), 
        std::move(p_params));
      return true;
    }
    case messages::ActorHandler::kGetContextForActorFromTab: {
      break;
    }
    case messages::ActorHandler::kCreateTask: {
      break;
    }
    case messages::ActorHandler::kPerformActions: {
      break;
    }
    case messages::ActorHandler::kCancelActions: {
      break;
    }
    case messages::ActorHandler::kStopActorTask: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_StopActorTask_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_StopActorTask_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.7
      bool success = true;
      int32_t p_task_id{};
      ActorTaskStopReason p_stop_reason{};
      ActorHandler_StopActorTask_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadStopReason(&p_stop_reason))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 7, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->StopActorTask(        
        std::move(p_task_id), 
        std::move(p_stop_reason));
      return true;
    }
    case messages::ActorHandler::kPauseActorTask: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_PauseActorTask_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_PauseActorTask_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.8
      bool success = true;
      int32_t p_task_id{};
      ActorTaskPauseReason p_pause_reason{};
      std::optional<int32_t> p_tab_id{};
      ActorHandler_PauseActorTask_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadPauseReason(&p_pause_reason))
        success = false;
      if (success) {
        p_tab_id = input_data_view.tab_id();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 8, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PauseActorTask(        
        std::move(p_task_id), 
        std::move(p_pause_reason), 
        std::move(p_tab_id));
      return true;
    }
    case messages::ActorHandler::kResumeActorTask: {
      break;
    }
    case messages::ActorHandler::kInterruptActorTask: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_InterruptActorTask_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_InterruptActorTask_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.10
      bool success = true;
      int32_t p_task_id{};
      std::optional<ActorTaskInterruptReason> p_interrupt_reason{};
      ActorHandler_InterruptActorTask_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadInterruptReason(&p_interrupt_reason)) {
        success = false;
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 10, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->InterruptActorTask(        
        std::move(p_task_id), 
        std::move(p_interrupt_reason));
      return true;
    }
    case messages::ActorHandler::kUninterruptActorTask: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_UninterruptActorTask_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_UninterruptActorTask_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.11
      bool success = true;
      int32_t p_task_id{};
      ActorHandler_UninterruptActorTask_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 11, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UninterruptActorTask(        
        std::move(p_task_id));
      return true;
    }
    case messages::ActorHandler::kUpdateActorTaskStepProgress: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_UpdateActorTaskStepProgress_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_UpdateActorTaskStepProgress_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.12
      bool success = true;
      int32_t p_task_id{};
      std::string p_step_progress{};
      ActorHandler_UpdateActorTaskStepProgress_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadStepProgress(&p_step_progress))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 12, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UpdateActorTaskStepProgress(        
        std::move(p_task_id), 
        std::move(p_step_progress));
      return true;
    }
    case messages::ActorHandler::kCreateActorTab: {
      break;
    }
    case messages::ActorHandler::kLogBeginAsyncEvent: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_LogBeginAsyncEvent_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_LogBeginAsyncEvent_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.14
      bool success = true;
      uint64_t p_event_async_id{};
      int32_t p_task_id{};
      std::string p_event{};
      std::string p_details{};
      ActorHandler_LogBeginAsyncEvent_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_event_async_id = input_data_view.event_async_id();
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadEvent(&p_event))
        success = false;
      if (success && !input_data_view.ReadDetails(&p_details))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 14, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->LogBeginAsyncEvent(        
        std::move(p_event_async_id), 
        std::move(p_task_id), 
        std::move(p_event), 
        std::move(p_details));
      return true;
    }
    case messages::ActorHandler::kLogEndAsyncEvent: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_LogEndAsyncEvent_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_LogEndAsyncEvent_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.15
      bool success = true;
      uint64_t p_event_async_id{};
      std::string p_details{};
      ActorHandler_LogEndAsyncEvent_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_event_async_id = input_data_view.event_async_id();
      if (success && !input_data_view.ReadDetails(&p_details))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 15, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->LogEndAsyncEvent(        
        std::move(p_event_async_id), 
        std::move(p_details));
      return true;
    }
    case messages::ActorHandler::kLogInstantEvent: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_LogInstantEvent_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_LogInstantEvent_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.16
      bool success = true;
      int32_t p_task_id{};
      std::string p_event{};
      std::string p_details{};
      ActorHandler_LogInstantEvent_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadEvent(&p_event))
        success = false;
      if (success && !input_data_view.ReadDetails(&p_details))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 16, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->LogInstantEvent(        
        std::move(p_task_id), 
        std::move(p_event), 
        std::move(p_details));
      return true;
    }
    case messages::ActorHandler::kJournalClear: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_JournalClear_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_JournalClear_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.17
      bool success = true;
      ActorHandler_JournalClear_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 17, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->JournalClear(        );
      return true;
    }
    case messages::ActorHandler::kJournalSnapshot: {
      break;
    }
    case messages::ActorHandler::kJournalStart: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_JournalStart_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_JournalStart_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.19
      bool success = true;
      uint64_t p_max_bytes{};
      bool p_capture_screenshots{};
      ActorHandler_JournalStart_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_max_bytes = input_data_view.max_bytes();
      if (success)
        p_capture_screenshots = input_data_view.capture_screenshots();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 19, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->JournalStart(        
        std::move(p_max_bytes), 
        std::move(p_capture_screenshots));
      return true;
    }
    case messages::ActorHandler::kJournalStop: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_JournalStop_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_JournalStop_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.20
      bool success = true;
      ActorHandler_JournalStop_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 20, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->JournalStop(        );
      return true;
    }
    case messages::ActorHandler::kJournalRecordFeedback: {
      DCHECK(message->is_serialized());
      internal::ActorHandler_JournalRecordFeedback_Params_Data* params =
          reinterpret_cast<internal::ActorHandler_JournalRecordFeedback_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ActorHandler.21
      bool success = true;
      bool p_positive{};
      std::string p_reason{};
      ActorHandler_JournalRecordFeedback_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_positive = input_data_view.positive();
      if (success && !input_data_view.ReadReason(&p_reason))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 21, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->JournalRecordFeedback(        
        std::move(p_positive), 
        std::move(p_reason));
      return true;
    }
  }
  return false;
}

// static
bool ActorHandlerStubDispatch::AcceptWithResponder(
    ActorHandler* 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::ActorHandler>(message->header()->name)) {
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormPresented: {
      break;
    }
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormPreviewChanged: {
      break;
    }
    case messages::ActorHandler::kAutofillSuggestionDialogOnFormConfirmed: {
      break;
    }
    case messages::ActorHandler::kGetContextForActorFromTab: {
      internal::ActorHandler_GetContextForActorFromTab_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_GetContextForActorFromTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.3
      bool success = true;
      int32_t p_tab_id{};
      TabContextOptionsPtr p_options{};
      ActorHandler_GetContextForActorFromTab_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 3, false);
        return false;
      }
      auto callback =
          ActorHandler_GetContextForActorFromTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetContextForActorFromTab(        
        std::move(p_tab_id), 
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kCreateTask: {
      internal::ActorHandler_CreateTask_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_CreateTask_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.4
      bool success = true;
      ::actor::webui::mojom::TaskOptionsPtr p_task_options{};
      ActorHandler_CreateTask_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTaskOptions(&p_task_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 4, false);
        return false;
      }
      auto callback =
          ActorHandler_CreateTask_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateTask(        
        std::move(p_task_options), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kPerformActions: {
      internal::ActorHandler_PerformActions_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_PerformActions_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.5
      bool success = true;
      std::vector<uint8_t> p_actions_proto{};
      ActorHandler_PerformActions_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadActionsProto(&p_actions_proto))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 5, false);
        return false;
      }
      auto callback =
          ActorHandler_PerformActions_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PerformActions(        
        std::move(p_actions_proto), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kCancelActions: {
      internal::ActorHandler_CancelActions_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_CancelActions_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.6
      bool success = true;
      int32_t p_task_id{};
      ActorHandler_CancelActions_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 6, false);
        return false;
      }
      auto callback =
          ActorHandler_CancelActions_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CancelActions(        
        std::move(p_task_id), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kStopActorTask: {
      break;
    }
    case messages::ActorHandler::kPauseActorTask: {
      break;
    }
    case messages::ActorHandler::kResumeActorTask: {
      internal::ActorHandler_ResumeActorTask_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_ResumeActorTask_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.9
      bool success = true;
      int32_t p_task_id{};
      TabContextOptionsPtr p_context_options{};
      ActorHandler_ResumeActorTask_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadContextOptions(&p_context_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 9, false);
        return false;
      }
      auto callback =
          ActorHandler_ResumeActorTask_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ResumeActorTask(        
        std::move(p_task_id), 
        std::move(p_context_options), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kInterruptActorTask: {
      break;
    }
    case messages::ActorHandler::kUninterruptActorTask: {
      break;
    }
    case messages::ActorHandler::kUpdateActorTaskStepProgress: {
      break;
    }
    case messages::ActorHandler::kCreateActorTab: {
      internal::ActorHandler_CreateActorTab_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_CreateActorTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.13
      bool success = true;
      int32_t p_task_id{};
      CreateActorTabOptionsPtr p_options{};
      ActorHandler_CreateActorTab_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 13, false);
        return false;
      }
      auto callback =
          ActorHandler_CreateActorTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateActorTab(        
        std::move(p_task_id), 
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kLogBeginAsyncEvent: {
      break;
    }
    case messages::ActorHandler::kLogEndAsyncEvent: {
      break;
    }
    case messages::ActorHandler::kLogInstantEvent: {
      break;
    }
    case messages::ActorHandler::kJournalClear: {
      break;
    }
    case messages::ActorHandler::kJournalSnapshot: {
      internal::ActorHandler_JournalSnapshot_Params_Data* params =
          reinterpret_cast<
              internal::ActorHandler_JournalSnapshot_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ActorHandler.18
      bool success = true;
      bool p_clear_journal{};
      ActorHandler_JournalSnapshot_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_clear_journal = input_data_view.clear_journal();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ActorHandler::Name_, 18, false);
        return false;
      }
      auto callback =
          ActorHandler_JournalSnapshot_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->JournalSnapshot(        
        std::move(p_clear_journal), std::move(callback));
      return true;
    }
    case messages::ActorHandler::kJournalStart: {
      break;
    }
    case messages::ActorHandler::kJournalStop: {
      break;
    }
    case messages::ActorHandler::kJournalRecordFeedback: {
      break;
    }
  }
  return false;
}
namespace {

bool ValidateWithRuntimeFeature_ActorHandler_GetContextForActorFromTab(
  const void* data, mojo::internal::ValidationContext* validation_context) {
  if (!base::FeatureList::IsEnabled(::glic::mojom::features::kGlicActorTabContext)) {
    return false;
  }
  return internal::ActorHandler_GetContextForActorFromTab_Params_Data::Validate(
    data, validation_context);
}
}  // namespace
static const mojo::internal::GenericValidationInfo kActorHandlerValidationInfo[] = {
    { &internal::ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data::Validate,
     nullptr /* no response */},
    { &ValidateWithRuntimeFeature_ActorHandler_GetContextForActorFromTab,
     &internal::ActorHandler_GetContextForActorFromTab_ResponseParams_Data::Validate},
    { &internal::ActorHandler_CreateTask_Params_Data::Validate,
     &internal::ActorHandler_CreateTask_ResponseParams_Data::Validate},
    { &internal::ActorHandler_PerformActions_Params_Data::Validate,
     &internal::ActorHandler_PerformActions_ResponseParams_Data::Validate},
    { &internal::ActorHandler_CancelActions_Params_Data::Validate,
     &internal::ActorHandler_CancelActions_ResponseParams_Data::Validate},
    { &internal::ActorHandler_StopActorTask_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_PauseActorTask_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_ResumeActorTask_Params_Data::Validate,
     &internal::ActorHandler_ResumeActorTask_ResponseParams_Data::Validate},
    { &internal::ActorHandler_InterruptActorTask_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_UninterruptActorTask_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_UpdateActorTaskStepProgress_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_CreateActorTab_Params_Data::Validate,
     &internal::ActorHandler_CreateActorTab_ResponseParams_Data::Validate},
    { &internal::ActorHandler_LogBeginAsyncEvent_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_LogEndAsyncEvent_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_LogInstantEvent_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_JournalClear_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_JournalSnapshot_Params_Data::Validate,
     &internal::ActorHandler_JournalSnapshot_ResponseParams_Data::Validate},
    { &internal::ActorHandler_JournalStart_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_JournalStop_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ActorHandler_JournalRecordFeedback_Params_Data::Validate,
     nullptr /* no response */},
};

bool ActorHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::ActorHandler::Name_,
    kActorHandlerValidationInfo);
}

bool ActorHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::ActorHandler::Name_,
    kActorHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

AnnotationHandler::IPCStableHashFunction AnnotationHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::AnnotationHandler>(message.name())) {
    case messages::AnnotationHandler::kScrollTo: {
      return &AnnotationHandler::ScrollTo_Sym::IPCStableHash;
    }
    case messages::AnnotationHandler::kDropScrollToHighlight: {
      return &AnnotationHandler::DropScrollToHighlight_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* AnnotationHandler::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::AnnotationHandler>(message.name())) {
      case messages::AnnotationHandler::kScrollTo:
            return "Receive glic::mojom::AnnotationHandler::ScrollTo";
      case messages::AnnotationHandler::kDropScrollToHighlight:
            return "Receive glic::mojom::AnnotationHandler::DropScrollToHighlight";
    }
  } else {
    switch (static_cast<messages::AnnotationHandler>(message.name())) {
      case messages::AnnotationHandler::kScrollTo:
            return "Receive reply glic::mojom::AnnotationHandler::ScrollTo";
      case messages::AnnotationHandler::kDropScrollToHighlight:
            return "Receive reply glic::mojom::AnnotationHandler::DropScrollToHighlight";
    }
  }
  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 AnnotationHandler::ScrollTo_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 = 0x13a0edb9;  // IPCStableHash for glic::mojom::AnnotationHandler::ScrollTo
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t AnnotationHandler::DropScrollToHighlight_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 = 0xcf0c4822;  // IPCStableHash for glic::mojom::AnnotationHandler::DropScrollToHighlight
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class AnnotationHandler_ScrollTo_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  AnnotationHandler_ScrollTo_ForwardToCallback(
      AnnotationHandler::ScrollToCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  AnnotationHandler::ScrollToCallback callback_;
};

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

void AnnotationHandlerProxy::ScrollTo(
    ScrollToParamsPtr in_params, ScrollToCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::AnnotationHandler::ScrollTo", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type ScrollToParamsPtr>");
   });
#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::AnnotationHandler::kScrollTo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::AnnotationHandler_ScrollTo_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType> params_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ScrollToParamsDataView>(
    in_params,
    params_fragment);

  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 AnnotationHandler.ScrollTo request");

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

void AnnotationHandlerProxy::DropScrollToHighlight(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::AnnotationHandler::DropScrollToHighlight");
#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::AnnotationHandler::kDropScrollToHighlight), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::AnnotationHandler_DropScrollToHighlight_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(AnnotationHandler::Name_);
  message.set_method_name("DropScrollToHighlight");
#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);
}
class AnnotationHandler_ScrollTo_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static AnnotationHandler::ScrollToCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<AnnotationHandler_ScrollTo_ProxyToResponder> proxy(
        new AnnotationHandler_ScrollTo_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&AnnotationHandler_ScrollTo_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~AnnotationHandler_ScrollTo_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:
  AnnotationHandler_ScrollTo_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)
        << "AnnotationHandler::ScrollToCallback 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(
      std::optional<ScrollToErrorReason> in_error_reason);
};

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

  // Validation for AnnotationHandler.0
  bool success = true;
  std::optional<ScrollToErrorReason> p_error_reason{};
  AnnotationHandler_ScrollTo_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadErrorReason(&p_error_reason)) {
    success = false;
  }
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        AnnotationHandler::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_error_reason));
  }
  return true;
}

void AnnotationHandler_ScrollTo_ProxyToResponder::Run(
    std::optional<ScrollToErrorReason> in_error_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::AnnotationHandler::ScrollTo", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("error_reason"), in_error_reason,
                        "<value of type std::optional<ScrollToErrorReason>>");
   });
#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::AnnotationHandler::kScrollTo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::AnnotationHandler_ScrollTo_ResponseParams_Data> params(
          message);
  params.Allocate();
  params->error_reason_$flag = in_error_reason.has_value();
  if (in_error_reason.has_value()) {
    
    mojo::internal::Serialize<::glic::mojom::ScrollToErrorReason>(
      in_error_reason.value(),
      &params->error_reason_$value);
  } else {
    params->error_reason_$value =
        static_cast<int32_t>(::glic::mojom::ScrollToErrorReason::kMinValue);
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(AnnotationHandler::Name_);
  message.set_method_name("ScrollTo");
#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 AnnotationHandlerStubDispatch::Accept(
    AnnotationHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::AnnotationHandler>(message->header()->name)) {
    case messages::AnnotationHandler::kScrollTo: {
      break;
    }
    case messages::AnnotationHandler::kDropScrollToHighlight: {
      DCHECK(message->is_serialized());
      internal::AnnotationHandler_DropScrollToHighlight_Params_Data* params =
          reinterpret_cast<internal::AnnotationHandler_DropScrollToHighlight_Params_Data*>(
              message->mutable_payload());
      

      // Validation for AnnotationHandler.1
      bool success = true;
      AnnotationHandler_DropScrollToHighlight_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            AnnotationHandler::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DropScrollToHighlight(        );
      return true;
    }
  }
  return false;
}

// static
bool AnnotationHandlerStubDispatch::AcceptWithResponder(
    AnnotationHandler* 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::AnnotationHandler>(message->header()->name)) {
    case messages::AnnotationHandler::kScrollTo: {
      internal::AnnotationHandler_ScrollTo_Params_Data* params =
          reinterpret_cast<
              internal::AnnotationHandler_ScrollTo_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for AnnotationHandler.0
      bool success = true;
      ScrollToParamsPtr p_params{};
      AnnotationHandler_ScrollTo_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            AnnotationHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          AnnotationHandler_ScrollTo_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ScrollTo(        
        std::move(p_params), std::move(callback));
      return true;
    }
    case messages::AnnotationHandler::kDropScrollToHighlight: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kAnnotationHandlerValidationInfo[] = {
    { &internal::AnnotationHandler_ScrollTo_Params_Data::Validate,
     &internal::AnnotationHandler_ScrollTo_ResponseParams_Data::Validate},
    { &internal::AnnotationHandler_DropScrollToHighlight_Params_Data::Validate,
     nullptr /* no response */},
};

bool AnnotationHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::AnnotationHandler::Name_,
    kAnnotationHandlerValidationInfo);
}

bool AnnotationHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::AnnotationHandler::Name_,
    kAnnotationHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

SkillsHandler::IPCStableHashFunction SkillsHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::SkillsHandler>(message.name())) {
    case messages::SkillsHandler::kCreateSkill: {
      return &SkillsHandler::CreateSkill_Sym::IPCStableHash;
    }
    case messages::SkillsHandler::kUpdateSkill: {
      return &SkillsHandler::UpdateSkill_Sym::IPCStableHash;
    }
    case messages::SkillsHandler::kShowManageSkillsUi: {
      return &SkillsHandler::ShowManageSkillsUi_Sym::IPCStableHash;
    }
    case messages::SkillsHandler::kShowBrowseSkillsUi: {
      return &SkillsHandler::ShowBrowseSkillsUi_Sym::IPCStableHash;
    }
    case messages::SkillsHandler::kGetSkill: {
      return &SkillsHandler::GetSkill_Sym::IPCStableHash;
    }
    case messages::SkillsHandler::kRecordSkillsWebClientEvent: {
      return &SkillsHandler::RecordSkillsWebClientEvent_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* SkillsHandler::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::SkillsHandler>(message.name())) {
      case messages::SkillsHandler::kCreateSkill:
            return "Receive glic::mojom::SkillsHandler::CreateSkill";
      case messages::SkillsHandler::kUpdateSkill:
            return "Receive glic::mojom::SkillsHandler::UpdateSkill";
      case messages::SkillsHandler::kShowManageSkillsUi:
            return "Receive glic::mojom::SkillsHandler::ShowManageSkillsUi";
      case messages::SkillsHandler::kShowBrowseSkillsUi:
            return "Receive glic::mojom::SkillsHandler::ShowBrowseSkillsUi";
      case messages::SkillsHandler::kGetSkill:
            return "Receive glic::mojom::SkillsHandler::GetSkill";
      case messages::SkillsHandler::kRecordSkillsWebClientEvent:
            return "Receive glic::mojom::SkillsHandler::RecordSkillsWebClientEvent";
    }
  } else {
    switch (static_cast<messages::SkillsHandler>(message.name())) {
      case messages::SkillsHandler::kCreateSkill:
            return "Receive reply glic::mojom::SkillsHandler::CreateSkill";
      case messages::SkillsHandler::kUpdateSkill:
            return "Receive reply glic::mojom::SkillsHandler::UpdateSkill";
      case messages::SkillsHandler::kShowManageSkillsUi:
            return "Receive reply glic::mojom::SkillsHandler::ShowManageSkillsUi";
      case messages::SkillsHandler::kShowBrowseSkillsUi:
            return "Receive reply glic::mojom::SkillsHandler::ShowBrowseSkillsUi";
      case messages::SkillsHandler::kGetSkill:
            return "Receive reply glic::mojom::SkillsHandler::GetSkill";
      case messages::SkillsHandler::kRecordSkillsWebClientEvent:
            return "Receive reply glic::mojom::SkillsHandler::RecordSkillsWebClientEvent";
    }
  }
  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 SkillsHandler::CreateSkill_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 = 0x81663896;  // IPCStableHash for glic::mojom::SkillsHandler::CreateSkill
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsHandler::UpdateSkill_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 = 0xfccebaac;  // IPCStableHash for glic::mojom::SkillsHandler::UpdateSkill
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsHandler::ShowManageSkillsUi_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 = 0xc4fb7aef;  // IPCStableHash for glic::mojom::SkillsHandler::ShowManageSkillsUi
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsHandler::ShowBrowseSkillsUi_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 = 0x96b59c5f;  // IPCStableHash for glic::mojom::SkillsHandler::ShowBrowseSkillsUi
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsHandler::GetSkill_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 = 0x8931d6c4;  // IPCStableHash for glic::mojom::SkillsHandler::GetSkill
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsHandler::RecordSkillsWebClientEvent_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 = 0xc701d391;  // IPCStableHash for glic::mojom::SkillsHandler::RecordSkillsWebClientEvent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class SkillsHandler_CreateSkill_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  SkillsHandler_CreateSkill_ForwardToCallback(
      SkillsHandler::CreateSkillCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  SkillsHandler::CreateSkillCallback callback_;
};

class SkillsHandler_UpdateSkill_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  SkillsHandler_UpdateSkill_ForwardToCallback(
      SkillsHandler::UpdateSkillCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  SkillsHandler::UpdateSkillCallback callback_;
};

class SkillsHandler_GetSkill_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  SkillsHandler_GetSkill_ForwardToCallback(
      SkillsHandler::GetSkillCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  SkillsHandler::GetSkillCallback callback_;
};

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

void SkillsHandlerProxy::CreateSkill(
    CreateSkillRequestPtr in_request, CreateSkillCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsHandler::CreateSkill", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type CreateSkillRequestPtr>");
   });
#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::SkillsHandler::kCreateSkill), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_CreateSkill_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::CreateSkillRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void SkillsHandlerProxy::UpdateSkill(
    UpdateSkillRequestPtr in_request, UpdateSkillCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsHandler::UpdateSkill", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request"), in_request,
                        "<value of type UpdateSkillRequestPtr>");
   });
#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::SkillsHandler::kUpdateSkill), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_UpdateSkill_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->request)::BaseType> request_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::UpdateSkillRequestDataView>(
    in_request,
    request_fragment);

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

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

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

void SkillsHandlerProxy::ShowManageSkillsUi(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::SkillsHandler::ShowManageSkillsUi");
#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::SkillsHandler::kShowManageSkillsUi), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_ShowManageSkillsUi_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsHandler::Name_);
  message.set_method_name("ShowManageSkillsUi");
#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 SkillsHandlerProxy::ShowBrowseSkillsUi(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::SkillsHandler::ShowBrowseSkillsUi");
#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::SkillsHandler::kShowBrowseSkillsUi), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_ShowBrowseSkillsUi_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsHandler::Name_);
  message.set_method_name("ShowBrowseSkillsUi");
#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 SkillsHandlerProxy::GetSkill(
    const std::string& in_id, GetSkillCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsHandler::GetSkill", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("id"), in_id,
                        "<value of type const std::string&>");
   });
#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::SkillsHandler::kGetSkill), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_GetSkill_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->id)::BaseType> id_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_id,
    id_fragment);

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

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

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

void SkillsHandlerProxy::RecordSkillsWebClientEvent(
    SkillsWebClientEvent in_event) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsHandler::RecordSkillsWebClientEvent", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("event"), in_event,
                        "<value of type SkillsWebClientEvent>");
   });
#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::SkillsHandler::kRecordSkillsWebClientEvent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_RecordSkillsWebClientEvent_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::SkillsWebClientEvent>(
    in_event,
    &params->event);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsHandler::Name_);
  message.set_method_name("RecordSkillsWebClientEvent");
#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);
}
class SkillsHandler_CreateSkill_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static SkillsHandler::CreateSkillCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<SkillsHandler_CreateSkill_ProxyToResponder> proxy(
        new SkillsHandler_CreateSkill_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&SkillsHandler_CreateSkill_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~SkillsHandler_CreateSkill_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:
  SkillsHandler_CreateSkill_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)
        << "SkillsHandler::CreateSkillCallback 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 in_modal_opened);
};

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

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

void SkillsHandler_CreateSkill_ProxyToResponder::Run(
    bool in_modal_opened) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::SkillsHandler::CreateSkill", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("modal_opened"), in_modal_opened,
                        "<value of type bool>");
   });
#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::SkillsHandler::kCreateSkill), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_CreateSkill_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->modal_opened = in_modal_opened;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsHandler::Name_);
  message.set_method_name("CreateSkill");
#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 SkillsHandler_UpdateSkill_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static SkillsHandler::UpdateSkillCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<SkillsHandler_UpdateSkill_ProxyToResponder> proxy(
        new SkillsHandler_UpdateSkill_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&SkillsHandler_UpdateSkill_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~SkillsHandler_UpdateSkill_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:
  SkillsHandler_UpdateSkill_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)
        << "SkillsHandler::UpdateSkillCallback 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 in_modal_opened);
};

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

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

void SkillsHandler_UpdateSkill_ProxyToResponder::Run(
    bool in_modal_opened) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::SkillsHandler::UpdateSkill", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("modal_opened"), in_modal_opened,
                        "<value of type bool>");
   });
#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::SkillsHandler::kUpdateSkill), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_UpdateSkill_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->modal_opened = in_modal_opened;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsHandler::Name_);
  message.set_method_name("UpdateSkill");
#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 SkillsHandler_GetSkill_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static SkillsHandler::GetSkillCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<SkillsHandler_GetSkill_ProxyToResponder> proxy(
        new SkillsHandler_GetSkill_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&SkillsHandler_GetSkill_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~SkillsHandler_GetSkill_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:
  SkillsHandler_GetSkill_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)
        << "SkillsHandler::GetSkillCallback 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(
      SkillPtr in_skill);
};

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

  // Validation for SkillsHandler.4
  bool success = true;
  SkillPtr p_skill{};
  SkillsHandler_GetSkill_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadSkill(&p_skill))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        SkillsHandler::Name_, 4, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_skill));
  }
  return true;
}

void SkillsHandler_GetSkill_ProxyToResponder::Run(
    SkillPtr in_skill) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::SkillsHandler::GetSkill", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("skill"), in_skill,
                        "<value of type SkillPtr>");
   });
#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::SkillsHandler::kGetSkill), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsHandler_GetSkill_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->skill)::BaseType> skill_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::SkillDataView>(
    in_skill,
    skill_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsHandler::Name_);
  message.set_method_name("GetSkill");
#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 SkillsHandlerStubDispatch::Accept(
    SkillsHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::SkillsHandler>(message->header()->name)) {
    case messages::SkillsHandler::kCreateSkill: {
      break;
    }
    case messages::SkillsHandler::kUpdateSkill: {
      break;
    }
    case messages::SkillsHandler::kShowManageSkillsUi: {
      DCHECK(message->is_serialized());
      internal::SkillsHandler_ShowManageSkillsUi_Params_Data* params =
          reinterpret_cast<internal::SkillsHandler_ShowManageSkillsUi_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsHandler.2
      bool success = true;
      SkillsHandler_ShowManageSkillsUi_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsHandler::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowManageSkillsUi(        );
      return true;
    }
    case messages::SkillsHandler::kShowBrowseSkillsUi: {
      DCHECK(message->is_serialized());
      internal::SkillsHandler_ShowBrowseSkillsUi_Params_Data* params =
          reinterpret_cast<internal::SkillsHandler_ShowBrowseSkillsUi_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsHandler.3
      bool success = true;
      SkillsHandler_ShowBrowseSkillsUi_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsHandler::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowBrowseSkillsUi(        );
      return true;
    }
    case messages::SkillsHandler::kGetSkill: {
      break;
    }
    case messages::SkillsHandler::kRecordSkillsWebClientEvent: {
      DCHECK(message->is_serialized());
      internal::SkillsHandler_RecordSkillsWebClientEvent_Params_Data* params =
          reinterpret_cast<internal::SkillsHandler_RecordSkillsWebClientEvent_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsHandler.5
      bool success = true;
      SkillsWebClientEvent p_event{};
      SkillsHandler_RecordSkillsWebClientEvent_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,
            SkillsHandler::Name_, 5, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RecordSkillsWebClientEvent(        
        std::move(p_event));
      return true;
    }
  }
  return false;
}

// static
bool SkillsHandlerStubDispatch::AcceptWithResponder(
    SkillsHandler* 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::SkillsHandler>(message->header()->name)) {
    case messages::SkillsHandler::kCreateSkill: {
      internal::SkillsHandler_CreateSkill_Params_Data* params =
          reinterpret_cast<
              internal::SkillsHandler_CreateSkill_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for SkillsHandler.0
      bool success = true;
      CreateSkillRequestPtr p_request{};
      SkillsHandler_CreateSkill_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          SkillsHandler_CreateSkill_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateSkill(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::SkillsHandler::kUpdateSkill: {
      internal::SkillsHandler_UpdateSkill_Params_Data* params =
          reinterpret_cast<
              internal::SkillsHandler_UpdateSkill_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for SkillsHandler.1
      bool success = true;
      UpdateSkillRequestPtr p_request{};
      SkillsHandler_UpdateSkill_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadRequest(&p_request))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsHandler::Name_, 1, false);
        return false;
      }
      auto callback =
          SkillsHandler_UpdateSkill_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UpdateSkill(        
        std::move(p_request), std::move(callback));
      return true;
    }
    case messages::SkillsHandler::kShowManageSkillsUi: {
      break;
    }
    case messages::SkillsHandler::kShowBrowseSkillsUi: {
      break;
    }
    case messages::SkillsHandler::kGetSkill: {
      internal::SkillsHandler_GetSkill_Params_Data* params =
          reinterpret_cast<
              internal::SkillsHandler_GetSkill_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for SkillsHandler.4
      bool success = true;
      std::string p_id{};
      SkillsHandler_GetSkill_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadId(&p_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsHandler::Name_, 4, false);
        return false;
      }
      auto callback =
          SkillsHandler_GetSkill_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetSkill(        
        std::move(p_id), std::move(callback));
      return true;
    }
    case messages::SkillsHandler::kRecordSkillsWebClientEvent: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kSkillsHandlerValidationInfo[] = {
    { &internal::SkillsHandler_CreateSkill_Params_Data::Validate,
     &internal::SkillsHandler_CreateSkill_ResponseParams_Data::Validate},
    { &internal::SkillsHandler_UpdateSkill_Params_Data::Validate,
     &internal::SkillsHandler_UpdateSkill_ResponseParams_Data::Validate},
    { &internal::SkillsHandler_ShowManageSkillsUi_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::SkillsHandler_ShowBrowseSkillsUi_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::SkillsHandler_GetSkill_Params_Data::Validate,
     &internal::SkillsHandler_GetSkill_ResponseParams_Data::Validate},
    { &internal::SkillsHandler_RecordSkillsWebClientEvent_Params_Data::Validate,
     nullptr /* no response */},
};

bool SkillsHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::SkillsHandler::Name_,
    kSkillsHandlerValidationInfo);
}

bool SkillsHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::SkillsHandler::Name_,
    kSkillsHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

SkillsClient::IPCStableHashFunction SkillsClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::SkillsClient>(message.name())) {
    case messages::SkillsClient::kNotifySkillPreviewsChanged: {
      return &SkillsClient::NotifySkillPreviewsChanged_Sym::IPCStableHash;
    }
    case messages::SkillsClient::kNotifyContextualSkillPreviewsChanged: {
      return &SkillsClient::NotifyContextualSkillPreviewsChanged_Sym::IPCStableHash;
    }
    case messages::SkillsClient::kNotifySkillPreviewChanged: {
      return &SkillsClient::NotifySkillPreviewChanged_Sym::IPCStableHash;
    }
    case messages::SkillsClient::kNotifySkillDeleted: {
      return &SkillsClient::NotifySkillDeleted_Sym::IPCStableHash;
    }
    case messages::SkillsClient::kNotifySkillsEnabledChanged: {
      return &SkillsClient::NotifySkillsEnabledChanged_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* SkillsClient::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::SkillsClient>(message.name())) {
      case messages::SkillsClient::kNotifySkillPreviewsChanged:
            return "Receive glic::mojom::SkillsClient::NotifySkillPreviewsChanged";
      case messages::SkillsClient::kNotifyContextualSkillPreviewsChanged:
            return "Receive glic::mojom::SkillsClient::NotifyContextualSkillPreviewsChanged";
      case messages::SkillsClient::kNotifySkillPreviewChanged:
            return "Receive glic::mojom::SkillsClient::NotifySkillPreviewChanged";
      case messages::SkillsClient::kNotifySkillDeleted:
            return "Receive glic::mojom::SkillsClient::NotifySkillDeleted";
      case messages::SkillsClient::kNotifySkillsEnabledChanged:
            return "Receive glic::mojom::SkillsClient::NotifySkillsEnabledChanged";
    }
  } else {
    switch (static_cast<messages::SkillsClient>(message.name())) {
      case messages::SkillsClient::kNotifySkillPreviewsChanged:
            return "Receive reply glic::mojom::SkillsClient::NotifySkillPreviewsChanged";
      case messages::SkillsClient::kNotifyContextualSkillPreviewsChanged:
            return "Receive reply glic::mojom::SkillsClient::NotifyContextualSkillPreviewsChanged";
      case messages::SkillsClient::kNotifySkillPreviewChanged:
            return "Receive reply glic::mojom::SkillsClient::NotifySkillPreviewChanged";
      case messages::SkillsClient::kNotifySkillDeleted:
            return "Receive reply glic::mojom::SkillsClient::NotifySkillDeleted";
      case messages::SkillsClient::kNotifySkillsEnabledChanged:
            return "Receive reply glic::mojom::SkillsClient::NotifySkillsEnabledChanged";
    }
  }
  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 SkillsClient::NotifySkillPreviewsChanged_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 = 0x3c5ec32e;  // IPCStableHash for glic::mojom::SkillsClient::NotifySkillPreviewsChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsClient::NotifyContextualSkillPreviewsChanged_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 = 0x536a928d;  // IPCStableHash for glic::mojom::SkillsClient::NotifyContextualSkillPreviewsChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsClient::NotifySkillPreviewChanged_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 = 0xe08c6459;  // IPCStableHash for glic::mojom::SkillsClient::NotifySkillPreviewChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsClient::NotifySkillDeleted_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 = 0x62e83d0f;  // IPCStableHash for glic::mojom::SkillsClient::NotifySkillDeleted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t SkillsClient::NotifySkillsEnabledChanged_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 = 0x5a36a5b6;  // IPCStableHash for glic::mojom::SkillsClient::NotifySkillsEnabledChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void SkillsClientProxy::NotifySkillPreviewsChanged(
    std::vector<SkillPreviewPtr> in_skill_previews) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsClient::NotifySkillPreviewsChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("skill_previews"), in_skill_previews,
                        "<value of type std::vector<SkillPreviewPtr>>");
   });
#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::SkillsClient::kNotifySkillPreviewsChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsClient_NotifySkillPreviewsChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->skill_previews)::BaseType>
      skill_previews_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& skill_previews_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::SkillPreviewDataView>>(
    in_skill_previews,
    skill_previews_fragment,
    &skill_previews_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsClient::Name_);
  message.set_method_name("NotifySkillPreviewsChanged");
#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 SkillsClientProxy::NotifyContextualSkillPreviewsChanged(
    std::vector<SkillPreviewPtr> in_skill_previews) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsClient::NotifyContextualSkillPreviewsChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("skill_previews"), in_skill_previews,
                        "<value of type std::vector<SkillPreviewPtr>>");
   });
#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::SkillsClient::kNotifyContextualSkillPreviewsChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->skill_previews)::BaseType>
      skill_previews_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& skill_previews_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::SkillPreviewDataView>>(
    in_skill_previews,
    skill_previews_fragment,
    &skill_previews_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsClient::Name_);
  message.set_method_name("NotifyContextualSkillPreviewsChanged");
#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 SkillsClientProxy::NotifySkillPreviewChanged(
    SkillPreviewPtr in_skill_preview) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsClient::NotifySkillPreviewChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("skill_preview"), in_skill_preview,
                        "<value of type SkillPreviewPtr>");
   });
#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::SkillsClient::kNotifySkillPreviewChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsClient_NotifySkillPreviewChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->skill_preview)::BaseType> skill_preview_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::SkillPreviewDataView>(
    in_skill_preview,
    skill_preview_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsClient::Name_);
  message.set_method_name("NotifySkillPreviewChanged");
#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 SkillsClientProxy::NotifySkillDeleted(
    const std::string& in_skill_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsClient::NotifySkillDeleted", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("skill_id"), in_skill_id,
                        "<value of type const std::string&>");
   });
#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::SkillsClient::kNotifySkillDeleted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsClient_NotifySkillDeleted_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->skill_id)::BaseType> skill_id_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_skill_id,
    skill_id_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsClient::Name_);
  message.set_method_name("NotifySkillDeleted");
#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 SkillsClientProxy::NotifySkillsEnabledChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::SkillsClient::NotifySkillsEnabledChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::SkillsClient::kNotifySkillsEnabledChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::SkillsClient_NotifySkillsEnabledChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(SkillsClient::Name_);
  message.set_method_name("NotifySkillsEnabledChanged");
#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 SkillsClientStubDispatch::Accept(
    SkillsClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::SkillsClient>(message->header()->name)) {
    case messages::SkillsClient::kNotifySkillPreviewsChanged: {
      DCHECK(message->is_serialized());
      internal::SkillsClient_NotifySkillPreviewsChanged_Params_Data* params =
          reinterpret_cast<internal::SkillsClient_NotifySkillPreviewsChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsClient.0
      bool success = true;
      std::vector<SkillPreviewPtr> p_skill_previews{};
      SkillsClient_NotifySkillPreviewsChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSkillPreviews(&p_skill_previews))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsClient::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifySkillPreviewsChanged(        
        std::move(p_skill_previews));
      return true;
    }
    case messages::SkillsClient::kNotifyContextualSkillPreviewsChanged: {
      DCHECK(message->is_serialized());
      internal::SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data* params =
          reinterpret_cast<internal::SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsClient.1
      bool success = true;
      std::vector<SkillPreviewPtr> p_skill_previews{};
      SkillsClient_NotifyContextualSkillPreviewsChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSkillPreviews(&p_skill_previews))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsClient::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyContextualSkillPreviewsChanged(        
        std::move(p_skill_previews));
      return true;
    }
    case messages::SkillsClient::kNotifySkillPreviewChanged: {
      DCHECK(message->is_serialized());
      internal::SkillsClient_NotifySkillPreviewChanged_Params_Data* params =
          reinterpret_cast<internal::SkillsClient_NotifySkillPreviewChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsClient.2
      bool success = true;
      SkillPreviewPtr p_skill_preview{};
      SkillsClient_NotifySkillPreviewChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSkillPreview(&p_skill_preview))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsClient::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifySkillPreviewChanged(        
        std::move(p_skill_preview));
      return true;
    }
    case messages::SkillsClient::kNotifySkillDeleted: {
      DCHECK(message->is_serialized());
      internal::SkillsClient_NotifySkillDeleted_Params_Data* params =
          reinterpret_cast<internal::SkillsClient_NotifySkillDeleted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsClient.3
      bool success = true;
      std::string p_skill_id{};
      SkillsClient_NotifySkillDeleted_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSkillId(&p_skill_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsClient::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifySkillDeleted(        
        std::move(p_skill_id));
      return true;
    }
    case messages::SkillsClient::kNotifySkillsEnabledChanged: {
      DCHECK(message->is_serialized());
      internal::SkillsClient_NotifySkillsEnabledChanged_Params_Data* params =
          reinterpret_cast<internal::SkillsClient_NotifySkillsEnabledChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for SkillsClient.4
      bool success = true;
      bool p_enabled{};
      SkillsClient_NotifySkillsEnabledChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            SkillsClient::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifySkillsEnabledChanged(        
        std::move(p_enabled));
      return true;
    }
  }
  return false;
}

// static
bool SkillsClientStubDispatch::AcceptWithResponder(
    SkillsClient* 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::SkillsClient>(message->header()->name)) {
    case messages::SkillsClient::kNotifySkillPreviewsChanged: {
      break;
    }
    case messages::SkillsClient::kNotifyContextualSkillPreviewsChanged: {
      break;
    }
    case messages::SkillsClient::kNotifySkillPreviewChanged: {
      break;
    }
    case messages::SkillsClient::kNotifySkillDeleted: {
      break;
    }
    case messages::SkillsClient::kNotifySkillsEnabledChanged: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kSkillsClientValidationInfo[] = {
    { &internal::SkillsClient_NotifySkillPreviewsChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::SkillsClient_NotifySkillPreviewChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::SkillsClient_NotifySkillDeleted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::SkillsClient_NotifySkillsEnabledChanged_Params_Data::Validate,
     nullptr /* no response */},
};

bool SkillsClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::SkillsClient::Name_,
    kSkillsClientValidationInfo);
}

// The declaration includes the definition on other builds.

WebClientHandler::IPCStableHashFunction WebClientHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::WebClientHandler>(message.name())) {
    case messages::WebClientHandler::kWebClientCreated: {
      return &WebClientHandler::WebClientCreated_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kWebClientInitialized: {
      return &WebClientHandler::WebClientInitialized_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kWebClientInitializeFailed: {
      return &WebClientHandler::WebClientInitializeFailed_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCreateActorHandler: {
      return &WebClientHandler::CreateActorHandler_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCreateExperimentalTriggeringClient: {
      return &WebClientHandler::CreateExperimentalTriggeringClient_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCreateAnnotationHandler: {
      return &WebClientHandler::CreateAnnotationHandler_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCreateSkillsHandler: {
      return &WebClientHandler::CreateSkillsHandler_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCreateZeroStateSuggestionsHandler: {
      return &WebClientHandler::CreateZeroStateSuggestionsHandler_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCreateTab: {
      return &WebClientHandler::CreateTab_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kActivateTabWithUrl: {
      return &WebClientHandler::ActivateTabWithUrl_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOpenLinkInPopup: {
      return &WebClientHandler::OpenLinkInPopup_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOpenGlicSettingsPage: {
      return &WebClientHandler::OpenGlicSettingsPage_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOpenPasswordManagerSettingsPage: {
      return &WebClientHandler::OpenPasswordManagerSettingsPage_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kEnableDragResize: {
      return &WebClientHandler::EnableDragResize_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kClosePanel: {
      return &WebClientHandler::ClosePanel_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kClosePanelAndShutdown: {
      return &WebClientHandler::ClosePanelAndShutdown_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kAttachPanel: {
      return &WebClientHandler::AttachPanel_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kDetachPanel: {
      return &WebClientHandler::DetachPanel_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnModeChange: {
      return &WebClientHandler::OnModeChange_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnMicrophoneStatusChange: {
      return &WebClientHandler::OnMicrophoneStatusChange_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kShowProfilePicker: {
      return &WebClientHandler::ShowProfilePicker_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetModelQualityClientId: {
      return &WebClientHandler::GetModelQualityClientId_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetContextFromFocusedTab: {
      return &WebClientHandler::GetContextFromFocusedTab_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetContextFromTab: {
      return &WebClientHandler::GetContextFromTab_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetImageBytesFromTab: {
      return &WebClientHandler::GetImageBytesFromTab_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetMaximumNumberOfPinnedTabs: {
      return &WebClientHandler::SetMaximumNumberOfPinnedTabs_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kPinTabs: {
      return &WebClientHandler::PinTabs_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kUnpinTabs: {
      return &WebClientHandler::UnpinTabs_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kUnpinAllTabs: {
      return &WebClientHandler::UnpinAllTabs_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSubscribeToPinCandidates: {
      return &WebClientHandler::SubscribeToPinCandidates_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOpenPinnedTabPicker: {
      return &WebClientHandler::OpenPinnedTabPicker_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kActivateTab: {
      return &WebClientHandler::ActivateTab_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kResizeWidget: {
      return &WebClientHandler::ResizeWidget_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCaptureScreenshot: {
      return &WebClientHandler::CaptureScreenshot_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kCaptureRegion: {
      return &WebClientHandler::CaptureRegion_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kDeleteCapturedRegion: {
      return &WebClientHandler::DeleteCapturedRegion_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetAudioDucking: {
      return &WebClientHandler::SetAudioDucking_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetMinimumPanelSize: {
      return &WebClientHandler::SetMinimumPanelSize_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetMicrophonePermissionState: {
      return &WebClientHandler::SetMicrophonePermissionState_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetLocationPermissionState: {
      return &WebClientHandler::SetLocationPermissionState_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetTabContextPermissionState: {
      return &WebClientHandler::SetTabContextPermissionState_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetClosedCaptioningSetting: {
      return &WebClientHandler::SetClosedCaptioningSetting_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetActuationOnWebSetting: {
      return &WebClientHandler::SetActuationOnWebSetting_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kShouldAllowMediaPermissionRequest: {
      return &WebClientHandler::ShouldAllowMediaPermissionRequest_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kShouldAllowGeolocationPermissionRequest: {
      return &WebClientHandler::ShouldAllowGeolocationPermissionRequest_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetContextAccessIndicator: {
      return &WebClientHandler::SetContextAccessIndicator_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetUserProfileInfo: {
      return &WebClientHandler::GetUserProfileInfo_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSyncCookies: {
      return &WebClientHandler::SyncCookies_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kClientErrorDialogStateChanged: {
      return &WebClientHandler::ClientErrorDialogStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kReportClientTransientError: {
      return &WebClientHandler::ReportClientTransientError_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kProcessCounterAbuseVerdict: {
      return &WebClientHandler::ProcessCounterAbuseVerdict_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnOptinImpression: {
      return &WebClientHandler::OnOptinImpression_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnUserInputSubmitted: {
      return &WebClientHandler::OnUserInputSubmitted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnContextUploadStarted: {
      return &WebClientHandler::OnContextUploadStarted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnContextUploadCompleted: {
      return &WebClientHandler::OnContextUploadCompleted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnReaction: {
      return &WebClientHandler::OnReaction_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnResponseStarted: {
      return &WebClientHandler::OnResponseStarted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnResponseStopped: {
      return &WebClientHandler::OnResponseStopped_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnSessionTerminated: {
      return &WebClientHandler::OnSessionTerminated_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnTurnCompleted: {
      return &WebClientHandler::OnTurnCompleted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnResponseRated: {
      return &WebClientHandler::OnResponseRated_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnClosedCaptionsShown: {
      return &WebClientHandler::OnClosedCaptionsShown_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOnActionSubmitted: {
      return &WebClientHandler::OnActionSubmitted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetSyntheticExperimentState: {
      return &WebClientHandler::SetSyntheticExperimentState_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kOpenOsPermissionSettingsMenu: {
      return &WebClientHandler::OpenOsPermissionSettingsMenu_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetOsMicrophonePermissionStatus: {
      return &WebClientHandler::GetOsMicrophonePermissionStatus_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab: {
      return &WebClientHandler::GetZeroStateSuggestionsForFocusedTab_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kMaybeRefreshUserStatus: {
      return &WebClientHandler::MaybeRefreshUserStatus_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kIsDebuggerAttached: {
      return &WebClientHandler::IsDebuggerAttached_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSubscribeToPageMetadata: {
      return &WebClientHandler::SubscribeToPageMetadata_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSwitchConversation: {
      return &WebClientHandler::SwitchConversation_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kRegisterConversation: {
      return &WebClientHandler::RegisterConversation_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSetOnboardingCompleted: {
      return &WebClientHandler::SetOnboardingCompleted_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSubscribeToTabData: {
      return &WebClientHandler::SubscribeToTabData_Sym::IPCStableHash;
    }
    case messages::WebClientHandler::kSubscribeToTabFavicon: {
      return &WebClientHandler::SubscribeToTabFavicon_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* WebClientHandler::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::WebClientHandler>(message.name())) {
      case messages::WebClientHandler::kWebClientCreated:
            return "Receive glic::mojom::WebClientHandler::WebClientCreated";
      case messages::WebClientHandler::kWebClientInitialized:
            return "Receive glic::mojom::WebClientHandler::WebClientInitialized";
      case messages::WebClientHandler::kWebClientInitializeFailed:
            return "Receive glic::mojom::WebClientHandler::WebClientInitializeFailed";
      case messages::WebClientHandler::kCreateActorHandler:
            return "Receive glic::mojom::WebClientHandler::CreateActorHandler";
      case messages::WebClientHandler::kCreateExperimentalTriggeringClient:
            return "Receive glic::mojom::WebClientHandler::CreateExperimentalTriggeringClient";
      case messages::WebClientHandler::kCreateAnnotationHandler:
            return "Receive glic::mojom::WebClientHandler::CreateAnnotationHandler";
      case messages::WebClientHandler::kCreateSkillsHandler:
            return "Receive glic::mojom::WebClientHandler::CreateSkillsHandler";
      case messages::WebClientHandler::kCreateZeroStateSuggestionsHandler:
            return "Receive glic::mojom::WebClientHandler::CreateZeroStateSuggestionsHandler";
      case messages::WebClientHandler::kCreateTab:
            return "Receive glic::mojom::WebClientHandler::CreateTab";
      case messages::WebClientHandler::kActivateTabWithUrl:
            return "Receive glic::mojom::WebClientHandler::ActivateTabWithUrl";
      case messages::WebClientHandler::kOpenLinkInPopup:
            return "Receive glic::mojom::WebClientHandler::OpenLinkInPopup";
      case messages::WebClientHandler::kOpenGlicSettingsPage:
            return "Receive glic::mojom::WebClientHandler::OpenGlicSettingsPage";
      case messages::WebClientHandler::kOpenPasswordManagerSettingsPage:
            return "Receive glic::mojom::WebClientHandler::OpenPasswordManagerSettingsPage";
      case messages::WebClientHandler::kEnableDragResize:
            return "Receive glic::mojom::WebClientHandler::EnableDragResize";
      case messages::WebClientHandler::kClosePanel:
            return "Receive glic::mojom::WebClientHandler::ClosePanel";
      case messages::WebClientHandler::kClosePanelAndShutdown:
            return "Receive glic::mojom::WebClientHandler::ClosePanelAndShutdown";
      case messages::WebClientHandler::kAttachPanel:
            return "Receive glic::mojom::WebClientHandler::AttachPanel";
      case messages::WebClientHandler::kDetachPanel:
            return "Receive glic::mojom::WebClientHandler::DetachPanel";
      case messages::WebClientHandler::kOnModeChange:
            return "Receive glic::mojom::WebClientHandler::OnModeChange";
      case messages::WebClientHandler::kOnMicrophoneStatusChange:
            return "Receive glic::mojom::WebClientHandler::OnMicrophoneStatusChange";
      case messages::WebClientHandler::kShowProfilePicker:
            return "Receive glic::mojom::WebClientHandler::ShowProfilePicker";
      case messages::WebClientHandler::kGetModelQualityClientId:
            return "Receive glic::mojom::WebClientHandler::GetModelQualityClientId";
      case messages::WebClientHandler::kGetContextFromFocusedTab:
            return "Receive glic::mojom::WebClientHandler::GetContextFromFocusedTab";
      case messages::WebClientHandler::kGetContextFromTab:
            return "Receive glic::mojom::WebClientHandler::GetContextFromTab";
      case messages::WebClientHandler::kGetImageBytesFromTab:
            return "Receive glic::mojom::WebClientHandler::GetImageBytesFromTab";
      case messages::WebClientHandler::kSetMaximumNumberOfPinnedTabs:
            return "Receive glic::mojom::WebClientHandler::SetMaximumNumberOfPinnedTabs";
      case messages::WebClientHandler::kPinTabs:
            return "Receive glic::mojom::WebClientHandler::PinTabs";
      case messages::WebClientHandler::kUnpinTabs:
            return "Receive glic::mojom::WebClientHandler::UnpinTabs";
      case messages::WebClientHandler::kUnpinAllTabs:
            return "Receive glic::mojom::WebClientHandler::UnpinAllTabs";
      case messages::WebClientHandler::kSubscribeToPinCandidates:
            return "Receive glic::mojom::WebClientHandler::SubscribeToPinCandidates";
      case messages::WebClientHandler::kOpenPinnedTabPicker:
            return "Receive glic::mojom::WebClientHandler::OpenPinnedTabPicker";
      case messages::WebClientHandler::kActivateTab:
            return "Receive glic::mojom::WebClientHandler::ActivateTab";
      case messages::WebClientHandler::kResizeWidget:
            return "Receive glic::mojom::WebClientHandler::ResizeWidget";
      case messages::WebClientHandler::kCaptureScreenshot:
            return "Receive glic::mojom::WebClientHandler::CaptureScreenshot";
      case messages::WebClientHandler::kCaptureRegion:
            return "Receive glic::mojom::WebClientHandler::CaptureRegion";
      case messages::WebClientHandler::kDeleteCapturedRegion:
            return "Receive glic::mojom::WebClientHandler::DeleteCapturedRegion";
      case messages::WebClientHandler::kSetAudioDucking:
            return "Receive glic::mojom::WebClientHandler::SetAudioDucking";
      case messages::WebClientHandler::kSetMinimumPanelSize:
            return "Receive glic::mojom::WebClientHandler::SetMinimumPanelSize";
      case messages::WebClientHandler::kSetMicrophonePermissionState:
            return "Receive glic::mojom::WebClientHandler::SetMicrophonePermissionState";
      case messages::WebClientHandler::kSetLocationPermissionState:
            return "Receive glic::mojom::WebClientHandler::SetLocationPermissionState";
      case messages::WebClientHandler::kSetTabContextPermissionState:
            return "Receive glic::mojom::WebClientHandler::SetTabContextPermissionState";
      case messages::WebClientHandler::kSetClosedCaptioningSetting:
            return "Receive glic::mojom::WebClientHandler::SetClosedCaptioningSetting";
      case messages::WebClientHandler::kSetActuationOnWebSetting:
            return "Receive glic::mojom::WebClientHandler::SetActuationOnWebSetting";
      case messages::WebClientHandler::kShouldAllowMediaPermissionRequest:
            return "Receive glic::mojom::WebClientHandler::ShouldAllowMediaPermissionRequest";
      case messages::WebClientHandler::kShouldAllowGeolocationPermissionRequest:
            return "Receive glic::mojom::WebClientHandler::ShouldAllowGeolocationPermissionRequest";
      case messages::WebClientHandler::kSetContextAccessIndicator:
            return "Receive glic::mojom::WebClientHandler::SetContextAccessIndicator";
      case messages::WebClientHandler::kGetUserProfileInfo:
            return "Receive glic::mojom::WebClientHandler::GetUserProfileInfo";
      case messages::WebClientHandler::kSyncCookies:
            return "Receive glic::mojom::WebClientHandler::SyncCookies";
      case messages::WebClientHandler::kClientErrorDialogStateChanged:
            return "Receive glic::mojom::WebClientHandler::ClientErrorDialogStateChanged";
      case messages::WebClientHandler::kReportClientTransientError:
            return "Receive glic::mojom::WebClientHandler::ReportClientTransientError";
      case messages::WebClientHandler::kProcessCounterAbuseVerdict:
            return "Receive glic::mojom::WebClientHandler::ProcessCounterAbuseVerdict";
      case messages::WebClientHandler::kOnOptinImpression:
            return "Receive glic::mojom::WebClientHandler::OnOptinImpression";
      case messages::WebClientHandler::kOnUserInputSubmitted:
            return "Receive glic::mojom::WebClientHandler::OnUserInputSubmitted";
      case messages::WebClientHandler::kOnContextUploadStarted:
            return "Receive glic::mojom::WebClientHandler::OnContextUploadStarted";
      case messages::WebClientHandler::kOnContextUploadCompleted:
            return "Receive glic::mojom::WebClientHandler::OnContextUploadCompleted";
      case messages::WebClientHandler::kOnReaction:
            return "Receive glic::mojom::WebClientHandler::OnReaction";
      case messages::WebClientHandler::kOnResponseStarted:
            return "Receive glic::mojom::WebClientHandler::OnResponseStarted";
      case messages::WebClientHandler::kOnResponseStopped:
            return "Receive glic::mojom::WebClientHandler::OnResponseStopped";
      case messages::WebClientHandler::kOnSessionTerminated:
            return "Receive glic::mojom::WebClientHandler::OnSessionTerminated";
      case messages::WebClientHandler::kOnTurnCompleted:
            return "Receive glic::mojom::WebClientHandler::OnTurnCompleted";
      case messages::WebClientHandler::kOnResponseRated:
            return "Receive glic::mojom::WebClientHandler::OnResponseRated";
      case messages::WebClientHandler::kOnClosedCaptionsShown:
            return "Receive glic::mojom::WebClientHandler::OnClosedCaptionsShown";
      case messages::WebClientHandler::kOnActionSubmitted:
            return "Receive glic::mojom::WebClientHandler::OnActionSubmitted";
      case messages::WebClientHandler::kSetSyntheticExperimentState:
            return "Receive glic::mojom::WebClientHandler::SetSyntheticExperimentState";
      case messages::WebClientHandler::kOpenOsPermissionSettingsMenu:
            return "Receive glic::mojom::WebClientHandler::OpenOsPermissionSettingsMenu";
      case messages::WebClientHandler::kGetOsMicrophonePermissionStatus:
            return "Receive glic::mojom::WebClientHandler::GetOsMicrophonePermissionStatus";
      case messages::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab:
            return "Receive glic::mojom::WebClientHandler::GetZeroStateSuggestionsForFocusedTab";
      case messages::WebClientHandler::kMaybeRefreshUserStatus:
            return "Receive glic::mojom::WebClientHandler::MaybeRefreshUserStatus";
      case messages::WebClientHandler::kIsDebuggerAttached:
            return "Receive glic::mojom::WebClientHandler::IsDebuggerAttached";
      case messages::WebClientHandler::kSubscribeToPageMetadata:
            return "Receive glic::mojom::WebClientHandler::SubscribeToPageMetadata";
      case messages::WebClientHandler::kSwitchConversation:
            return "Receive glic::mojom::WebClientHandler::SwitchConversation";
      case messages::WebClientHandler::kRegisterConversation:
            return "Receive glic::mojom::WebClientHandler::RegisterConversation";
      case messages::WebClientHandler::kSetOnboardingCompleted:
            return "Receive glic::mojom::WebClientHandler::SetOnboardingCompleted";
      case messages::WebClientHandler::kSubscribeToTabData:
            return "Receive glic::mojom::WebClientHandler::SubscribeToTabData";
      case messages::WebClientHandler::kSubscribeToTabFavicon:
            return "Receive glic::mojom::WebClientHandler::SubscribeToTabFavicon";
    }
  } else {
    switch (static_cast<messages::WebClientHandler>(message.name())) {
      case messages::WebClientHandler::kWebClientCreated:
            return "Receive reply glic::mojom::WebClientHandler::WebClientCreated";
      case messages::WebClientHandler::kWebClientInitialized:
            return "Receive reply glic::mojom::WebClientHandler::WebClientInitialized";
      case messages::WebClientHandler::kWebClientInitializeFailed:
            return "Receive reply glic::mojom::WebClientHandler::WebClientInitializeFailed";
      case messages::WebClientHandler::kCreateActorHandler:
            return "Receive reply glic::mojom::WebClientHandler::CreateActorHandler";
      case messages::WebClientHandler::kCreateExperimentalTriggeringClient:
            return "Receive reply glic::mojom::WebClientHandler::CreateExperimentalTriggeringClient";
      case messages::WebClientHandler::kCreateAnnotationHandler:
            return "Receive reply glic::mojom::WebClientHandler::CreateAnnotationHandler";
      case messages::WebClientHandler::kCreateSkillsHandler:
            return "Receive reply glic::mojom::WebClientHandler::CreateSkillsHandler";
      case messages::WebClientHandler::kCreateZeroStateSuggestionsHandler:
            return "Receive reply glic::mojom::WebClientHandler::CreateZeroStateSuggestionsHandler";
      case messages::WebClientHandler::kCreateTab:
            return "Receive reply glic::mojom::WebClientHandler::CreateTab";
      case messages::WebClientHandler::kActivateTabWithUrl:
            return "Receive reply glic::mojom::WebClientHandler::ActivateTabWithUrl";
      case messages::WebClientHandler::kOpenLinkInPopup:
            return "Receive reply glic::mojom::WebClientHandler::OpenLinkInPopup";
      case messages::WebClientHandler::kOpenGlicSettingsPage:
            return "Receive reply glic::mojom::WebClientHandler::OpenGlicSettingsPage";
      case messages::WebClientHandler::kOpenPasswordManagerSettingsPage:
            return "Receive reply glic::mojom::WebClientHandler::OpenPasswordManagerSettingsPage";
      case messages::WebClientHandler::kEnableDragResize:
            return "Receive reply glic::mojom::WebClientHandler::EnableDragResize";
      case messages::WebClientHandler::kClosePanel:
            return "Receive reply glic::mojom::WebClientHandler::ClosePanel";
      case messages::WebClientHandler::kClosePanelAndShutdown:
            return "Receive reply glic::mojom::WebClientHandler::ClosePanelAndShutdown";
      case messages::WebClientHandler::kAttachPanel:
            return "Receive reply glic::mojom::WebClientHandler::AttachPanel";
      case messages::WebClientHandler::kDetachPanel:
            return "Receive reply glic::mojom::WebClientHandler::DetachPanel";
      case messages::WebClientHandler::kOnModeChange:
            return "Receive reply glic::mojom::WebClientHandler::OnModeChange";
      case messages::WebClientHandler::kOnMicrophoneStatusChange:
            return "Receive reply glic::mojom::WebClientHandler::OnMicrophoneStatusChange";
      case messages::WebClientHandler::kShowProfilePicker:
            return "Receive reply glic::mojom::WebClientHandler::ShowProfilePicker";
      case messages::WebClientHandler::kGetModelQualityClientId:
            return "Receive reply glic::mojom::WebClientHandler::GetModelQualityClientId";
      case messages::WebClientHandler::kGetContextFromFocusedTab:
            return "Receive reply glic::mojom::WebClientHandler::GetContextFromFocusedTab";
      case messages::WebClientHandler::kGetContextFromTab:
            return "Receive reply glic::mojom::WebClientHandler::GetContextFromTab";
      case messages::WebClientHandler::kGetImageBytesFromTab:
            return "Receive reply glic::mojom::WebClientHandler::GetImageBytesFromTab";
      case messages::WebClientHandler::kSetMaximumNumberOfPinnedTabs:
            return "Receive reply glic::mojom::WebClientHandler::SetMaximumNumberOfPinnedTabs";
      case messages::WebClientHandler::kPinTabs:
            return "Receive reply glic::mojom::WebClientHandler::PinTabs";
      case messages::WebClientHandler::kUnpinTabs:
            return "Receive reply glic::mojom::WebClientHandler::UnpinTabs";
      case messages::WebClientHandler::kUnpinAllTabs:
            return "Receive reply glic::mojom::WebClientHandler::UnpinAllTabs";
      case messages::WebClientHandler::kSubscribeToPinCandidates:
            return "Receive reply glic::mojom::WebClientHandler::SubscribeToPinCandidates";
      case messages::WebClientHandler::kOpenPinnedTabPicker:
            return "Receive reply glic::mojom::WebClientHandler::OpenPinnedTabPicker";
      case messages::WebClientHandler::kActivateTab:
            return "Receive reply glic::mojom::WebClientHandler::ActivateTab";
      case messages::WebClientHandler::kResizeWidget:
            return "Receive reply glic::mojom::WebClientHandler::ResizeWidget";
      case messages::WebClientHandler::kCaptureScreenshot:
            return "Receive reply glic::mojom::WebClientHandler::CaptureScreenshot";
      case messages::WebClientHandler::kCaptureRegion:
            return "Receive reply glic::mojom::WebClientHandler::CaptureRegion";
      case messages::WebClientHandler::kDeleteCapturedRegion:
            return "Receive reply glic::mojom::WebClientHandler::DeleteCapturedRegion";
      case messages::WebClientHandler::kSetAudioDucking:
            return "Receive reply glic::mojom::WebClientHandler::SetAudioDucking";
      case messages::WebClientHandler::kSetMinimumPanelSize:
            return "Receive reply glic::mojom::WebClientHandler::SetMinimumPanelSize";
      case messages::WebClientHandler::kSetMicrophonePermissionState:
            return "Receive reply glic::mojom::WebClientHandler::SetMicrophonePermissionState";
      case messages::WebClientHandler::kSetLocationPermissionState:
            return "Receive reply glic::mojom::WebClientHandler::SetLocationPermissionState";
      case messages::WebClientHandler::kSetTabContextPermissionState:
            return "Receive reply glic::mojom::WebClientHandler::SetTabContextPermissionState";
      case messages::WebClientHandler::kSetClosedCaptioningSetting:
            return "Receive reply glic::mojom::WebClientHandler::SetClosedCaptioningSetting";
      case messages::WebClientHandler::kSetActuationOnWebSetting:
            return "Receive reply glic::mojom::WebClientHandler::SetActuationOnWebSetting";
      case messages::WebClientHandler::kShouldAllowMediaPermissionRequest:
            return "Receive reply glic::mojom::WebClientHandler::ShouldAllowMediaPermissionRequest";
      case messages::WebClientHandler::kShouldAllowGeolocationPermissionRequest:
            return "Receive reply glic::mojom::WebClientHandler::ShouldAllowGeolocationPermissionRequest";
      case messages::WebClientHandler::kSetContextAccessIndicator:
            return "Receive reply glic::mojom::WebClientHandler::SetContextAccessIndicator";
      case messages::WebClientHandler::kGetUserProfileInfo:
            return "Receive reply glic::mojom::WebClientHandler::GetUserProfileInfo";
      case messages::WebClientHandler::kSyncCookies:
            return "Receive reply glic::mojom::WebClientHandler::SyncCookies";
      case messages::WebClientHandler::kClientErrorDialogStateChanged:
            return "Receive reply glic::mojom::WebClientHandler::ClientErrorDialogStateChanged";
      case messages::WebClientHandler::kReportClientTransientError:
            return "Receive reply glic::mojom::WebClientHandler::ReportClientTransientError";
      case messages::WebClientHandler::kProcessCounterAbuseVerdict:
            return "Receive reply glic::mojom::WebClientHandler::ProcessCounterAbuseVerdict";
      case messages::WebClientHandler::kOnOptinImpression:
            return "Receive reply glic::mojom::WebClientHandler::OnOptinImpression";
      case messages::WebClientHandler::kOnUserInputSubmitted:
            return "Receive reply glic::mojom::WebClientHandler::OnUserInputSubmitted";
      case messages::WebClientHandler::kOnContextUploadStarted:
            return "Receive reply glic::mojom::WebClientHandler::OnContextUploadStarted";
      case messages::WebClientHandler::kOnContextUploadCompleted:
            return "Receive reply glic::mojom::WebClientHandler::OnContextUploadCompleted";
      case messages::WebClientHandler::kOnReaction:
            return "Receive reply glic::mojom::WebClientHandler::OnReaction";
      case messages::WebClientHandler::kOnResponseStarted:
            return "Receive reply glic::mojom::WebClientHandler::OnResponseStarted";
      case messages::WebClientHandler::kOnResponseStopped:
            return "Receive reply glic::mojom::WebClientHandler::OnResponseStopped";
      case messages::WebClientHandler::kOnSessionTerminated:
            return "Receive reply glic::mojom::WebClientHandler::OnSessionTerminated";
      case messages::WebClientHandler::kOnTurnCompleted:
            return "Receive reply glic::mojom::WebClientHandler::OnTurnCompleted";
      case messages::WebClientHandler::kOnResponseRated:
            return "Receive reply glic::mojom::WebClientHandler::OnResponseRated";
      case messages::WebClientHandler::kOnClosedCaptionsShown:
            return "Receive reply glic::mojom::WebClientHandler::OnClosedCaptionsShown";
      case messages::WebClientHandler::kOnActionSubmitted:
            return "Receive reply glic::mojom::WebClientHandler::OnActionSubmitted";
      case messages::WebClientHandler::kSetSyntheticExperimentState:
            return "Receive reply glic::mojom::WebClientHandler::SetSyntheticExperimentState";
      case messages::WebClientHandler::kOpenOsPermissionSettingsMenu:
            return "Receive reply glic::mojom::WebClientHandler::OpenOsPermissionSettingsMenu";
      case messages::WebClientHandler::kGetOsMicrophonePermissionStatus:
            return "Receive reply glic::mojom::WebClientHandler::GetOsMicrophonePermissionStatus";
      case messages::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab:
            return "Receive reply glic::mojom::WebClientHandler::GetZeroStateSuggestionsForFocusedTab";
      case messages::WebClientHandler::kMaybeRefreshUserStatus:
            return "Receive reply glic::mojom::WebClientHandler::MaybeRefreshUserStatus";
      case messages::WebClientHandler::kIsDebuggerAttached:
            return "Receive reply glic::mojom::WebClientHandler::IsDebuggerAttached";
      case messages::WebClientHandler::kSubscribeToPageMetadata:
            return "Receive reply glic::mojom::WebClientHandler::SubscribeToPageMetadata";
      case messages::WebClientHandler::kSwitchConversation:
            return "Receive reply glic::mojom::WebClientHandler::SwitchConversation";
      case messages::WebClientHandler::kRegisterConversation:
            return "Receive reply glic::mojom::WebClientHandler::RegisterConversation";
      case messages::WebClientHandler::kSetOnboardingCompleted:
            return "Receive reply glic::mojom::WebClientHandler::SetOnboardingCompleted";
      case messages::WebClientHandler::kSubscribeToTabData:
            return "Receive reply glic::mojom::WebClientHandler::SubscribeToTabData";
      case messages::WebClientHandler::kSubscribeToTabFavicon:
            return "Receive reply glic::mojom::WebClientHandler::SubscribeToTabFavicon";
    }
  }
  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 WebClientHandler::WebClientCreated_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 = 0x5577db8b;  // IPCStableHash for glic::mojom::WebClientHandler::WebClientCreated
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::WebClientInitialized_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 = 0xdf1de908;  // IPCStableHash for glic::mojom::WebClientHandler::WebClientInitialized
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::WebClientInitializeFailed_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 = 0xc8ca96a3;  // IPCStableHash for glic::mojom::WebClientHandler::WebClientInitializeFailed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CreateActorHandler_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 = 0xa5c8462e;  // IPCStableHash for glic::mojom::WebClientHandler::CreateActorHandler
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CreateExperimentalTriggeringClient_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 = 0x5aca6e10;  // IPCStableHash for glic::mojom::WebClientHandler::CreateExperimentalTriggeringClient
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CreateAnnotationHandler_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 = 0x5c18b042;  // IPCStableHash for glic::mojom::WebClientHandler::CreateAnnotationHandler
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CreateSkillsHandler_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 = 0x50fe2db7;  // IPCStableHash for glic::mojom::WebClientHandler::CreateSkillsHandler
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CreateZeroStateSuggestionsHandler_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 = 0xc7685892;  // IPCStableHash for glic::mojom::WebClientHandler::CreateZeroStateSuggestionsHandler
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CreateTab_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 = 0x076b050c;  // IPCStableHash for glic::mojom::WebClientHandler::CreateTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ActivateTabWithUrl_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 = 0x2c236a48;  // IPCStableHash for glic::mojom::WebClientHandler::ActivateTabWithUrl
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OpenLinkInPopup_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 = 0x923c8640;  // IPCStableHash for glic::mojom::WebClientHandler::OpenLinkInPopup
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OpenGlicSettingsPage_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 = 0x39a402e6;  // IPCStableHash for glic::mojom::WebClientHandler::OpenGlicSettingsPage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OpenPasswordManagerSettingsPage_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 = 0x1d8cce23;  // IPCStableHash for glic::mojom::WebClientHandler::OpenPasswordManagerSettingsPage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::EnableDragResize_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 = 0x5eb4aef9;  // IPCStableHash for glic::mojom::WebClientHandler::EnableDragResize
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ClosePanel_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 = 0x0a28f614;  // IPCStableHash for glic::mojom::WebClientHandler::ClosePanel
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ClosePanelAndShutdown_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 = 0x1522641a;  // IPCStableHash for glic::mojom::WebClientHandler::ClosePanelAndShutdown
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::AttachPanel_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 = 0xadfbc7fd;  // IPCStableHash for glic::mojom::WebClientHandler::AttachPanel
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::DetachPanel_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 = 0x71aa5698;  // IPCStableHash for glic::mojom::WebClientHandler::DetachPanel
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnModeChange_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 = 0x5e084fc1;  // IPCStableHash for glic::mojom::WebClientHandler::OnModeChange
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnMicrophoneStatusChange_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 = 0xfdbb84a2;  // IPCStableHash for glic::mojom::WebClientHandler::OnMicrophoneStatusChange
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ShowProfilePicker_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 = 0xaec7f803;  // IPCStableHash for glic::mojom::WebClientHandler::ShowProfilePicker
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetModelQualityClientId_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 = 0xded80892;  // IPCStableHash for glic::mojom::WebClientHandler::GetModelQualityClientId
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetContextFromFocusedTab_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 = 0xac51b530;  // IPCStableHash for glic::mojom::WebClientHandler::GetContextFromFocusedTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetContextFromTab_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 = 0x48ef89d1;  // IPCStableHash for glic::mojom::WebClientHandler::GetContextFromTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetImageBytesFromTab_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 = 0xbb620de0;  // IPCStableHash for glic::mojom::WebClientHandler::GetImageBytesFromTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetMaximumNumberOfPinnedTabs_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 = 0xa607417e;  // IPCStableHash for glic::mojom::WebClientHandler::SetMaximumNumberOfPinnedTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::PinTabs_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 = 0xb6a9fabb;  // IPCStableHash for glic::mojom::WebClientHandler::PinTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::UnpinTabs_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 = 0x1255c451;  // IPCStableHash for glic::mojom::WebClientHandler::UnpinTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::UnpinAllTabs_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 = 0x35530cf2;  // IPCStableHash for glic::mojom::WebClientHandler::UnpinAllTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SubscribeToPinCandidates_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 = 0x40392fcf;  // IPCStableHash for glic::mojom::WebClientHandler::SubscribeToPinCandidates
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OpenPinnedTabPicker_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 = 0x335f53e5;  // IPCStableHash for glic::mojom::WebClientHandler::OpenPinnedTabPicker
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ActivateTab_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 = 0x860b6049;  // IPCStableHash for glic::mojom::WebClientHandler::ActivateTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ResizeWidget_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 = 0x6b233a5a;  // IPCStableHash for glic::mojom::WebClientHandler::ResizeWidget
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CaptureScreenshot_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 = 0x5657ec2e;  // IPCStableHash for glic::mojom::WebClientHandler::CaptureScreenshot
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::CaptureRegion_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 = 0x76b92dcb;  // IPCStableHash for glic::mojom::WebClientHandler::CaptureRegion
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::DeleteCapturedRegion_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 = 0xcda652ed;  // IPCStableHash for glic::mojom::WebClientHandler::DeleteCapturedRegion
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetAudioDucking_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 = 0x29e43b27;  // IPCStableHash for glic::mojom::WebClientHandler::SetAudioDucking
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetMinimumPanelSize_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 = 0x6662b0cd;  // IPCStableHash for glic::mojom::WebClientHandler::SetMinimumPanelSize
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetMicrophonePermissionState_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 = 0xeacb4b69;  // IPCStableHash for glic::mojom::WebClientHandler::SetMicrophonePermissionState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetLocationPermissionState_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 = 0xd2dc2048;  // IPCStableHash for glic::mojom::WebClientHandler::SetLocationPermissionState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetTabContextPermissionState_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 = 0xdc9e749b;  // IPCStableHash for glic::mojom::WebClientHandler::SetTabContextPermissionState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetClosedCaptioningSetting_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 = 0x592a66a5;  // IPCStableHash for glic::mojom::WebClientHandler::SetClosedCaptioningSetting
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetActuationOnWebSetting_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 = 0xd6c00096;  // IPCStableHash for glic::mojom::WebClientHandler::SetActuationOnWebSetting
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ShouldAllowMediaPermissionRequest_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 = 0x0f5e2b61;  // IPCStableHash for glic::mojom::WebClientHandler::ShouldAllowMediaPermissionRequest
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ShouldAllowGeolocationPermissionRequest_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 = 0xf3e658e2;  // IPCStableHash for glic::mojom::WebClientHandler::ShouldAllowGeolocationPermissionRequest
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetContextAccessIndicator_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 = 0xf5954118;  // IPCStableHash for glic::mojom::WebClientHandler::SetContextAccessIndicator
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetUserProfileInfo_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 = 0xe14629dc;  // IPCStableHash for glic::mojom::WebClientHandler::GetUserProfileInfo
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SyncCookies_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 = 0xa9b3d03a;  // IPCStableHash for glic::mojom::WebClientHandler::SyncCookies
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ClientErrorDialogStateChanged_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 = 0x10e1039a;  // IPCStableHash for glic::mojom::WebClientHandler::ClientErrorDialogStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ReportClientTransientError_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 = 0x8425a188;  // IPCStableHash for glic::mojom::WebClientHandler::ReportClientTransientError
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::ProcessCounterAbuseVerdict_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 = 0xfb510873;  // IPCStableHash for glic::mojom::WebClientHandler::ProcessCounterAbuseVerdict
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnOptinImpression_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 = 0x770ede8b;  // IPCStableHash for glic::mojom::WebClientHandler::OnOptinImpression
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnUserInputSubmitted_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 = 0x3822de54;  // IPCStableHash for glic::mojom::WebClientHandler::OnUserInputSubmitted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnContextUploadStarted_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 = 0x5a367bae;  // IPCStableHash for glic::mojom::WebClientHandler::OnContextUploadStarted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnContextUploadCompleted_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 = 0xf4db4b1d;  // IPCStableHash for glic::mojom::WebClientHandler::OnContextUploadCompleted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnReaction_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 = 0x62b6e7e8;  // IPCStableHash for glic::mojom::WebClientHandler::OnReaction
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnResponseStarted_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 = 0xce56812f;  // IPCStableHash for glic::mojom::WebClientHandler::OnResponseStarted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnResponseStopped_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 = 0x7ac31e8e;  // IPCStableHash for glic::mojom::WebClientHandler::OnResponseStopped
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnSessionTerminated_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 = 0x7342f9d7;  // IPCStableHash for glic::mojom::WebClientHandler::OnSessionTerminated
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnTurnCompleted_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 = 0x357eceb8;  // IPCStableHash for glic::mojom::WebClientHandler::OnTurnCompleted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnResponseRated_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 = 0xeaa89b64;  // IPCStableHash for glic::mojom::WebClientHandler::OnResponseRated
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnClosedCaptionsShown_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 = 0x4bc0ff9d;  // IPCStableHash for glic::mojom::WebClientHandler::OnClosedCaptionsShown
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OnActionSubmitted_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 = 0xe6dc75f1;  // IPCStableHash for glic::mojom::WebClientHandler::OnActionSubmitted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetSyntheticExperimentState_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 = 0x5d17a3d1;  // IPCStableHash for glic::mojom::WebClientHandler::SetSyntheticExperimentState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::OpenOsPermissionSettingsMenu_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 = 0x35cf2b00;  // IPCStableHash for glic::mojom::WebClientHandler::OpenOsPermissionSettingsMenu
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetOsMicrophonePermissionStatus_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 = 0x76b7e8b8;  // IPCStableHash for glic::mojom::WebClientHandler::GetOsMicrophonePermissionStatus
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::GetZeroStateSuggestionsForFocusedTab_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 = 0x4f10d15e;  // IPCStableHash for glic::mojom::WebClientHandler::GetZeroStateSuggestionsForFocusedTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::MaybeRefreshUserStatus_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 = 0xf6eb9f3d;  // IPCStableHash for glic::mojom::WebClientHandler::MaybeRefreshUserStatus
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::IsDebuggerAttached_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 = 0xf73fad99;  // IPCStableHash for glic::mojom::WebClientHandler::IsDebuggerAttached
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SubscribeToPageMetadata_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 = 0x5f6df065;  // IPCStableHash for glic::mojom::WebClientHandler::SubscribeToPageMetadata
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SwitchConversation_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 = 0x141a6c86;  // IPCStableHash for glic::mojom::WebClientHandler::SwitchConversation
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::RegisterConversation_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 = 0x6f1492fa;  // IPCStableHash for glic::mojom::WebClientHandler::RegisterConversation
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SetOnboardingCompleted_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 = 0x68ca078b;  // IPCStableHash for glic::mojom::WebClientHandler::SetOnboardingCompleted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SubscribeToTabData_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 = 0x33c13679;  // IPCStableHash for glic::mojom::WebClientHandler::SubscribeToTabData
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClientHandler::SubscribeToTabFavicon_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 = 0x9c16045d;  // IPCStableHash for glic::mojom::WebClientHandler::SubscribeToTabFavicon
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class WebClientHandler_WebClientCreated_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_WebClientCreated_ForwardToCallback(
      WebClientHandler::WebClientCreatedCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::WebClientCreatedCallback callback_;
};

class WebClientHandler_CreateTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_CreateTab_ForwardToCallback(
      WebClientHandler::CreateTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::CreateTabCallback callback_;
};

class WebClientHandler_ActivateTabWithUrl_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_ActivateTabWithUrl_ForwardToCallback(
      WebClientHandler::ActivateTabWithUrlCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::ActivateTabWithUrlCallback callback_;
};

class WebClientHandler_GetModelQualityClientId_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetModelQualityClientId_ForwardToCallback(
      WebClientHandler::GetModelQualityClientIdCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetModelQualityClientIdCallback callback_;
};

class WebClientHandler_GetContextFromFocusedTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetContextFromFocusedTab_ForwardToCallback(
      WebClientHandler::GetContextFromFocusedTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetContextFromFocusedTabCallback callback_;
};

class WebClientHandler_GetContextFromTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetContextFromTab_ForwardToCallback(
      WebClientHandler::GetContextFromTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetContextFromTabCallback callback_;
};

class WebClientHandler_GetImageBytesFromTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetImageBytesFromTab_ForwardToCallback(
      WebClientHandler::GetImageBytesFromTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetImageBytesFromTabCallback callback_;
};

class WebClientHandler_SetMaximumNumberOfPinnedTabs_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetMaximumNumberOfPinnedTabs_ForwardToCallback(
      WebClientHandler::SetMaximumNumberOfPinnedTabsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetMaximumNumberOfPinnedTabsCallback callback_;
};

class WebClientHandler_PinTabs_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_PinTabs_ForwardToCallback(
      WebClientHandler::PinTabsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::PinTabsCallback callback_;
};

class WebClientHandler_UnpinTabs_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_UnpinTabs_ForwardToCallback(
      WebClientHandler::UnpinTabsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::UnpinTabsCallback callback_;
};

class WebClientHandler_OpenPinnedTabPicker_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_OpenPinnedTabPicker_ForwardToCallback(
      WebClientHandler::OpenPinnedTabPickerCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::OpenPinnedTabPickerCallback callback_;
};

class WebClientHandler_ResizeWidget_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_ResizeWidget_ForwardToCallback(
      WebClientHandler::ResizeWidgetCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::ResizeWidgetCallback callback_;
};

class WebClientHandler_CaptureScreenshot_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_CaptureScreenshot_ForwardToCallback(
      WebClientHandler::CaptureScreenshotCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::CaptureScreenshotCallback callback_;
};

class WebClientHandler_SetAudioDucking_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetAudioDucking_ForwardToCallback(
      WebClientHandler::SetAudioDuckingCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetAudioDuckingCallback callback_;
};

class WebClientHandler_SetMicrophonePermissionState_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetMicrophonePermissionState_ForwardToCallback(
      WebClientHandler::SetMicrophonePermissionStateCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetMicrophonePermissionStateCallback callback_;
};

class WebClientHandler_SetLocationPermissionState_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetLocationPermissionState_ForwardToCallback(
      WebClientHandler::SetLocationPermissionStateCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetLocationPermissionStateCallback callback_;
};

class WebClientHandler_SetTabContextPermissionState_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetTabContextPermissionState_ForwardToCallback(
      WebClientHandler::SetTabContextPermissionStateCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetTabContextPermissionStateCallback callback_;
};

class WebClientHandler_SetClosedCaptioningSetting_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetClosedCaptioningSetting_ForwardToCallback(
      WebClientHandler::SetClosedCaptioningSettingCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetClosedCaptioningSettingCallback callback_;
};

class WebClientHandler_SetActuationOnWebSetting_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SetActuationOnWebSetting_ForwardToCallback(
      WebClientHandler::SetActuationOnWebSettingCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SetActuationOnWebSettingCallback callback_;
};

class WebClientHandler_ShouldAllowMediaPermissionRequest_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_ShouldAllowMediaPermissionRequest_ForwardToCallback(
      WebClientHandler::ShouldAllowMediaPermissionRequestCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::ShouldAllowMediaPermissionRequestCallback callback_;
};

class WebClientHandler_ShouldAllowGeolocationPermissionRequest_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_ShouldAllowGeolocationPermissionRequest_ForwardToCallback(
      WebClientHandler::ShouldAllowGeolocationPermissionRequestCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::ShouldAllowGeolocationPermissionRequestCallback callback_;
};

class WebClientHandler_GetUserProfileInfo_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetUserProfileInfo_ForwardToCallback(
      WebClientHandler::GetUserProfileInfoCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetUserProfileInfoCallback callback_;
};

class WebClientHandler_SyncCookies_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SyncCookies_ForwardToCallback(
      WebClientHandler::SyncCookiesCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SyncCookiesCallback callback_;
};

class WebClientHandler_GetOsMicrophonePermissionStatus_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetOsMicrophonePermissionStatus_ForwardToCallback(
      WebClientHandler::GetOsMicrophonePermissionStatusCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetOsMicrophonePermissionStatusCallback callback_;
};

class WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ForwardToCallback(
      WebClientHandler::GetZeroStateSuggestionsForFocusedTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::GetZeroStateSuggestionsForFocusedTabCallback callback_;
};

class WebClientHandler_IsDebuggerAttached_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_IsDebuggerAttached_ForwardToCallback(
      WebClientHandler::IsDebuggerAttachedCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::IsDebuggerAttachedCallback callback_;
};

class WebClientHandler_SubscribeToPageMetadata_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SubscribeToPageMetadata_ForwardToCallback(
      WebClientHandler::SubscribeToPageMetadataCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SubscribeToPageMetadataCallback callback_;
};

class WebClientHandler_SwitchConversation_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_SwitchConversation_ForwardToCallback(
      WebClientHandler::SwitchConversationCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::SwitchConversationCallback callback_;
};

class WebClientHandler_RegisterConversation_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClientHandler_RegisterConversation_ForwardToCallback(
      WebClientHandler::RegisterConversationCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClientHandler::RegisterConversationCallback callback_;
};

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

void WebClientHandlerProxy::WebClientCreated(
    ::mojo::PendingRemote<WebClient> in_web_client, WebClientCreatedCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::WebClientCreated", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("web_client"), in_web_client,
                        "<value of type ::mojo::PendingRemote<WebClient>>");
   });
#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::WebClientHandler::kWebClientCreated), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_WebClientCreated_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::WebClientInterfaceBase>>(
    in_web_client,
    &params->web_client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->web_client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid web_client in WebClientHandler.WebClientCreated request");

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

void WebClientHandlerProxy::WebClientInitialized(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::WebClientInitialized");
#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::WebClientHandler::kWebClientInitialized), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_WebClientInitialized_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("WebClientInitialized");
#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 WebClientHandlerProxy::WebClientInitializeFailed(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::WebClientInitializeFailed");
#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::WebClientHandler::kWebClientInitializeFailed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_WebClientInitializeFailed_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("WebClientInitializeFailed");
#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 WebClientHandlerProxy::CreateActorHandler(
    ::mojo::PendingReceiver<ActorHandler> in_receiver, ::mojo::PendingRemote<ActorClient> in_client) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CreateActorHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingReceiver<ActorHandler>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("client"), in_client,
                        "<value of type ::mojo::PendingRemote<ActorClient>>");
   });
#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::WebClientHandler::kCreateActorHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateActorHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::glic::mojom::ActorHandlerInterfaceBase>>(
    in_receiver,
    &params->receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid receiver in WebClientHandler.CreateActorHandler request");

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::ActorClientInterfaceBase>>(
    in_client,
    &params->client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid client in WebClientHandler.CreateActorHandler request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CreateActorHandler");
#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 WebClientHandlerProxy::CreateExperimentalTriggeringClient(
    ::mojo::PendingRemote<ExperimentalTriggeringClient> in_client) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CreateExperimentalTriggeringClient", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("client"), in_client,
                        "<value of type ::mojo::PendingRemote<ExperimentalTriggeringClient>>");
   });
#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::WebClientHandler::kCreateExperimentalTriggeringClient), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateExperimentalTriggeringClient_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::ExperimentalTriggeringClientInterfaceBase>>(
    in_client,
    &params->client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid client in WebClientHandler.CreateExperimentalTriggeringClient request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CreateExperimentalTriggeringClient");
#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 WebClientHandlerProxy::CreateAnnotationHandler(
    ::mojo::PendingReceiver<AnnotationHandler> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CreateAnnotationHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingReceiver<AnnotationHandler>>");
   });
#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::WebClientHandler::kCreateAnnotationHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateAnnotationHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::glic::mojom::AnnotationHandlerInterfaceBase>>(
    in_receiver,
    &params->receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid receiver in WebClientHandler.CreateAnnotationHandler request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CreateAnnotationHandler");
#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 WebClientHandlerProxy::CreateSkillsHandler(
    ::mojo::PendingReceiver<SkillsHandler> in_receiver, ::mojo::PendingRemote<SkillsClient> in_client) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CreateSkillsHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingReceiver<SkillsHandler>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("client"), in_client,
                        "<value of type ::mojo::PendingRemote<SkillsClient>>");
   });
#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::WebClientHandler::kCreateSkillsHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateSkillsHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::glic::mojom::SkillsHandlerInterfaceBase>>(
    in_receiver,
    &params->receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid receiver in WebClientHandler.CreateSkillsHandler request");

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::SkillsClientInterfaceBase>>(
    in_client,
    &params->client,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->client)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid client in WebClientHandler.CreateSkillsHandler request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CreateSkillsHandler");
#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 WebClientHandlerProxy::CreateZeroStateSuggestionsHandler(
    ::mojo::PendingReceiver<ZeroStateSuggestionsHandler> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CreateZeroStateSuggestionsHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingReceiver<ZeroStateSuggestionsHandler>>");
   });
#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::WebClientHandler::kCreateZeroStateSuggestionsHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::glic::mojom::ZeroStateSuggestionsHandlerInterfaceBase>>(
    in_receiver,
    &params->receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid receiver in WebClientHandler.CreateZeroStateSuggestionsHandler request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CreateZeroStateSuggestionsHandler");
#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 WebClientHandlerProxy::CreateTab(
    const ::GURL& in_url, CreateTabOptionsPtr in_create_options, CreateTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CreateTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("create_options"), in_create_options,
                        "<value of type CreateTabOptionsPtr>");
   });
#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::WebClientHandler::kCreateTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateTab_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 WebClientHandler.CreateTab request");
  mojo::internal::MessageFragment<
      typename decltype(params->create_options)::BaseType> create_options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::CreateTabOptionsDataView>(
    in_create_options,
    create_options_fragment);

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

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

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

void WebClientHandlerProxy::ActivateTabWithUrl(
    const ::GURL& in_exact_url, ActivateTabOptionsPtr in_options, ActivateTabWithUrlCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::ActivateTabWithUrl", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("exact_url"), in_exact_url,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type ActivateTabOptionsPtr>");
   });
#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::WebClientHandler::kActivateTabWithUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ActivateTabWithUrl_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->exact_url)::BaseType> exact_url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_exact_url,
    exact_url_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->exact_url.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null exact_url in WebClientHandler.ActivateTabWithUrl request");
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ActivateTabOptionsDataView>(
    in_options,
    options_fragment);

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

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

void WebClientHandlerProxy::OpenLinkInPopup(
    const ::GURL& in_url, int32_t in_popup_width, int32_t in_popup_height) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OpenLinkInPopup", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("popup_width"), in_popup_width,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("popup_height"), in_popup_height,
                        "<value of type int32_t>");
   });
#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::WebClientHandler::kOpenLinkInPopup), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OpenLinkInPopup_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 WebClientHandler.OpenLinkInPopup request");

  params->popup_width = in_popup_width;

  params->popup_height = in_popup_height;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OpenLinkInPopup");
#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 WebClientHandlerProxy::OpenGlicSettingsPage(
    OpenSettingsOptionsPtr in_options) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OpenGlicSettingsPage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type OpenSettingsOptionsPtr>");
   });
#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::WebClientHandler::kOpenGlicSettingsPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OpenGlicSettingsPage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::OpenSettingsOptionsDataView>(
    in_options,
    options_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OpenGlicSettingsPage");
#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 WebClientHandlerProxy::OpenPasswordManagerSettingsPage(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OpenPasswordManagerSettingsPage");
#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::WebClientHandler::kOpenPasswordManagerSettingsPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OpenPasswordManagerSettingsPage");
#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 WebClientHandlerProxy::EnableDragResize(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::EnableDragResize", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kEnableDragResize), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_EnableDragResize_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("EnableDragResize");
#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 WebClientHandlerProxy::ClosePanel(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::ClosePanel");
#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::WebClientHandler::kClosePanel), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ClosePanel_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ClosePanel");
#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 WebClientHandlerProxy::ClosePanelAndShutdown(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::ClosePanelAndShutdown");
#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::WebClientHandler::kClosePanelAndShutdown), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ClosePanelAndShutdown_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ClosePanelAndShutdown");
#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 WebClientHandlerProxy::AttachPanel(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::AttachPanel");
#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::WebClientHandler::kAttachPanel), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_AttachPanel_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("AttachPanel");
#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 WebClientHandlerProxy::DetachPanel(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::DetachPanel");
#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::WebClientHandler::kDetachPanel), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_DetachPanel_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("DetachPanel");
#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 WebClientHandlerProxy::OnModeChange(
    WebClientMode in_new_mode) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnModeChange", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("new_mode"), in_new_mode,
                        "<value of type WebClientMode>");
   });
#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::WebClientHandler::kOnModeChange), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnModeChange_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::WebClientMode>(
    in_new_mode,
    &params->new_mode);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnModeChange");
#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 WebClientHandlerProxy::OnMicrophoneStatusChange(
    MicrophoneStatus in_status) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnMicrophoneStatusChange", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("status"), in_status,
                        "<value of type MicrophoneStatus>");
   });
#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::WebClientHandler::kOnMicrophoneStatusChange), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnMicrophoneStatusChange_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::MicrophoneStatus>(
    in_status,
    &params->status);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnMicrophoneStatusChange");
#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 WebClientHandlerProxy::ShowProfilePicker(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::ShowProfilePicker");
#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::WebClientHandler::kShowProfilePicker), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ShowProfilePicker_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ShowProfilePicker");
#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 WebClientHandlerProxy::GetModelQualityClientId(
    GetModelQualityClientIdCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::GetModelQualityClientId");
#endif

  CHECK(base::FeatureList::IsEnabled(::glic::mojom::features::kGlicAppendModelQualityClientId));
  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::WebClientHandler::kGetModelQualityClientId), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetModelQualityClientId_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::GetContextFromFocusedTab(
    TabContextOptionsPtr in_options, GetContextFromFocusedTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::GetContextFromFocusedTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type TabContextOptionsPtr>");
   });
#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::WebClientHandler::kGetContextFromFocusedTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetContextFromFocusedTab_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabContextOptionsDataView>(
    in_options,
    options_fragment);

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

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

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

void WebClientHandlerProxy::GetContextFromTab(
    int32_t in_tab_id, TabContextOptionsPtr in_options, GetContextFromTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::GetContextFromTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type TabContextOptionsPtr>");
   });
#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::WebClientHandler::kGetContextFromTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetContextFromTab_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabContextOptionsDataView>(
    in_options,
    options_fragment);

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

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

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

void WebClientHandlerProxy::GetImageBytesFromTab(
    int32_t in_tab_id, const std::string& in_document_id, int32_t in_dom_node_id, GetImageBytesFromTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::GetImageBytesFromTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("document_id"), in_document_id,
                        "<value of type const std::string&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("dom_node_id"), in_dom_node_id,
                        "<value of type int32_t>");
   });
#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::WebClientHandler::kGetImageBytesFromTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetImageBytesFromTab_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->document_id)::BaseType> document_id_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_document_id,
    document_id_fragment);

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

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

  params->dom_node_id = in_dom_node_id;

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

void WebClientHandlerProxy::SetMaximumNumberOfPinnedTabs(
    uint32_t in_requested_max, SetMaximumNumberOfPinnedTabsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetMaximumNumberOfPinnedTabs", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("requested_max"), in_requested_max,
                        "<value of type uint32_t>");
   });
#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::WebClientHandler::kSetMaximumNumberOfPinnedTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data> params(
          message);
  params.Allocate();

  params->requested_max = in_requested_max;

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

void WebClientHandlerProxy::PinTabs(
    const std::vector<int32_t>& in_tab_ids, PinTabsOptionsPtr in_options, PinTabsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::PinTabs", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_ids"), in_tab_ids,
                        "<value of type const std::vector<int32_t>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type PinTabsOptionsPtr>");
   });
#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::WebClientHandler::kPinTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_PinTabs_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_ids)::BaseType>
      tab_ids_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& tab_ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<int32_t>>(
    in_tab_ids,
    tab_ids_fragment,
    &tab_ids_validate_params);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->tab_ids.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null tab_ids in WebClientHandler.PinTabs request");
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::PinTabsOptionsDataView>(
    in_options,
    options_fragment);

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

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

void WebClientHandlerProxy::UnpinTabs(
    const std::vector<int32_t>& in_tab_ids, UnpinTabsOptionsPtr in_options, UnpinTabsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::UnpinTabs", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_ids"), in_tab_ids,
                        "<value of type const std::vector<int32_t>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type UnpinTabsOptionsPtr>");
   });
#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::WebClientHandler::kUnpinTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_UnpinTabs_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_ids)::BaseType>
      tab_ids_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& tab_ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<int32_t>>(
    in_tab_ids,
    tab_ids_fragment,
    &tab_ids_validate_params);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->tab_ids.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null tab_ids in WebClientHandler.UnpinTabs request");
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::UnpinTabsOptionsDataView>(
    in_options,
    options_fragment);

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

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

void WebClientHandlerProxy::UnpinAllTabs(
    UnpinTabsOptionsPtr in_options) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::UnpinAllTabs", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type UnpinTabsOptionsPtr>");
   });
#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::WebClientHandler::kUnpinAllTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_UnpinAllTabs_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::UnpinTabsOptionsDataView>(
    in_options,
    options_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("UnpinAllTabs");
#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 WebClientHandlerProxy::SubscribeToPinCandidates(
    GetPinCandidatesOptionsPtr in_options, ::mojo::PendingRemote<PinCandidatesObserver> in_observer) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SubscribeToPinCandidates", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type GetPinCandidatesOptionsPtr>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("observer"), in_observer,
                        "<value of type ::mojo::PendingRemote<PinCandidatesObserver>>");
   });
#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::WebClientHandler::kSubscribeToPinCandidates), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SubscribeToPinCandidates_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::GetPinCandidatesOptionsDataView>(
    in_options,
    options_fragment);

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

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

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::PinCandidatesObserverInterfaceBase>>(
    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 WebClientHandler.SubscribeToPinCandidates request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SubscribeToPinCandidates");
#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 WebClientHandlerProxy::OpenPinnedTabPicker(
    OpenPinnedTabPickerOptionsPtr in_options, OpenPinnedTabPickerCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OpenPinnedTabPicker", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type OpenPinnedTabPickerOptionsPtr>");
   });
#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::WebClientHandler::kOpenPinnedTabPicker), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OpenPinnedTabPicker_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::OpenPinnedTabPickerOptionsDataView>(
    in_options,
    options_fragment);

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

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

void WebClientHandlerProxy::ActivateTab(
    int32_t in_task_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::ActivateTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
   });
#endif

  CHECK(base::FeatureList::IsEnabled(::glic::mojom::features::kGlicActivateTabApi));
  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::WebClientHandler::kActivateTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ActivateTab_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ActivateTab");
#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 WebClientHandlerProxy::ResizeWidget(
    const ::gfx::Size& in_size, ::base::TimeDelta in_duration, ResizeWidgetCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::ResizeWidget", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("size"), in_size,
                        "<value of type const ::gfx::Size&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("duration"), in_duration,
                        "<value of type ::base::TimeDelta>");
   });
#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::WebClientHandler::kResizeWidget), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ResizeWidget_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->size)::BaseType> size_fragment(
          params.message());
  
  mojo::internal::Serialize<::gfx::mojom::SizeDataView>(
    in_size,
    size_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->size.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null size in WebClientHandler.ResizeWidget request");
  mojo::internal::MessageFragment<
      typename decltype(params->duration)::BaseType> duration_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::TimeDeltaDataView>(
    in_duration,
    duration_fragment);

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

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

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

void WebClientHandlerProxy::CaptureScreenshot(
    CaptureScreenshotCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::CaptureScreenshot");
#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::WebClientHandler::kCaptureScreenshot), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CaptureScreenshot_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::CaptureRegion(
    ::mojo::PendingRemote<CaptureRegionObserver> in_observer, CaptureRegionParamsPtr in_params) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::CaptureRegion", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("observer"), in_observer,
                        "<value of type ::mojo::PendingRemote<CaptureRegionObserver>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type CaptureRegionParamsPtr>");
   });
#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::WebClientHandler::kCaptureRegion), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CaptureRegion_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::CaptureRegionObserverInterfaceBase>>(
    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 WebClientHandler.CaptureRegion request");
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType> params_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::CaptureRegionParamsDataView>(
    in_params,
    params_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CaptureRegion");
#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 WebClientHandlerProxy::DeleteCapturedRegion(
    int32_t in_tab_id, const ::base::UnguessableToken& in_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::DeleteCapturedRegion", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("id"), in_id,
                        "<value of type const ::base::UnguessableToken&>");
   });
#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::WebClientHandler::kDeleteCapturedRegion), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_DeleteCapturedRegion_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->id)::BaseType> id_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView>(
    in_id,
    id_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("DeleteCapturedRegion");
#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 WebClientHandlerProxy::SetAudioDucking(
    bool in_enable, SetAudioDuckingCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetAudioDucking", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enable"), in_enable,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetAudioDucking), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetAudioDucking_Params_Data> params(
          message);
  params.Allocate();

  params->enable = in_enable;

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

void WebClientHandlerProxy::SetMinimumPanelSize(
    const ::gfx::Size& in_size) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetMinimumPanelSize", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("size"), in_size,
                        "<value of type const ::gfx::Size&>");
   });
#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::WebClientHandler::kSetMinimumPanelSize), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetMinimumPanelSize_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->size)::BaseType> size_fragment(
          params.message());
  
  mojo::internal::Serialize<::gfx::mojom::SizeDataView>(
    in_size,
    size_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetMinimumPanelSize");
#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 WebClientHandlerProxy::SetMicrophonePermissionState(
    bool in_enabled, SetMicrophonePermissionStateCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetMicrophonePermissionState", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetMicrophonePermissionState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetMicrophonePermissionState_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

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

void WebClientHandlerProxy::SetLocationPermissionState(
    bool in_enabled, SetLocationPermissionStateCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetLocationPermissionState", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetLocationPermissionState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetLocationPermissionState_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

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

void WebClientHandlerProxy::SetTabContextPermissionState(
    bool in_enabled, SetTabContextPermissionStateCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetTabContextPermissionState", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetTabContextPermissionState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetTabContextPermissionState_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

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

void WebClientHandlerProxy::SetClosedCaptioningSetting(
    bool in_enabled, SetClosedCaptioningSettingCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetClosedCaptioningSetting", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetClosedCaptioningSetting), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetClosedCaptioningSetting_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

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

void WebClientHandlerProxy::SetActuationOnWebSetting(
    bool in_enabled, SetActuationOnWebSettingCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetActuationOnWebSetting", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetActuationOnWebSetting), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetActuationOnWebSetting_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

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

void WebClientHandlerProxy::ShouldAllowMediaPermissionRequest(
    ShouldAllowMediaPermissionRequestCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::ShouldAllowMediaPermissionRequest");
#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::WebClientHandler::kShouldAllowMediaPermissionRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::ShouldAllowGeolocationPermissionRequest(
    ShouldAllowGeolocationPermissionRequestCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::ShouldAllowGeolocationPermissionRequest");
#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::WebClientHandler::kShouldAllowGeolocationPermissionRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::SetContextAccessIndicator(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetContextAccessIndicator", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetContextAccessIndicator), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetContextAccessIndicator_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetContextAccessIndicator");
#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 WebClientHandlerProxy::GetUserProfileInfo(
    GetUserProfileInfoCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::GetUserProfileInfo");
#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::WebClientHandler::kGetUserProfileInfo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetUserProfileInfo_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::SyncCookies(
    SyncCookiesCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::SyncCookies");
#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::WebClientHandler::kSyncCookies), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SyncCookies_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::ClientErrorDialogStateChanged(
    std::optional<ClientErrorDialogType> in_shown_dialog_type) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::ClientErrorDialogStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("shown_dialog_type"), in_shown_dialog_type,
                        "<value of type std::optional<ClientErrorDialogType>>");
   });
#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::WebClientHandler::kClientErrorDialogStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ClientErrorDialogStateChanged_Params_Data> params(
          message);
  params.Allocate();
  params->shown_dialog_type_$flag = in_shown_dialog_type.has_value();
  if (in_shown_dialog_type.has_value()) {
    
    mojo::internal::Serialize<::glic::mojom::ClientErrorDialogType>(
      in_shown_dialog_type.value(),
      &params->shown_dialog_type_$value);
  } else {
    params->shown_dialog_type_$value =
        static_cast<int32_t>(::glic::mojom::ClientErrorDialogType::kMinValue);
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ClientErrorDialogStateChanged");
#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 WebClientHandlerProxy::ReportClientTransientError(
    ::mojo_base::mojom::AbslStatusCode in_status_code) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::ReportClientTransientError", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("status_code"), in_status_code,
                        "<value of type ::mojo_base::mojom::AbslStatusCode>");
   });
#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::WebClientHandler::kReportClientTransientError), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ReportClientTransientError_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::mojo_base::mojom::AbslStatusCode>(
    in_status_code,
    &params->status_code);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ReportClientTransientError");
#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 WebClientHandlerProxy::ProcessCounterAbuseVerdict(
    int32_t in_tab_id, CounterAbuseVerdictPtr in_verdict) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::ProcessCounterAbuseVerdict", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("verdict"), in_verdict,
                        "<value of type CounterAbuseVerdictPtr>");
   });
#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::WebClientHandler::kProcessCounterAbuseVerdict), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ProcessCounterAbuseVerdict_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->verdict)::BaseType> verdict_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::CounterAbuseVerdictDataView>(
    in_verdict,
    verdict_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ProcessCounterAbuseVerdict");
#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 WebClientHandlerProxy::OnOptinImpression(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OnOptinImpression");
#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::WebClientHandler::kOnOptinImpression), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnOptinImpression_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnOptinImpression");
#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 WebClientHandlerProxy::OnUserInputSubmitted(
    WebClientMode in_mode, PromptType in_prompt_type) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnUserInputSubmitted", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("mode"), in_mode,
                        "<value of type WebClientMode>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("prompt_type"), in_prompt_type,
                        "<value of type PromptType>");
   });
#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::WebClientHandler::kOnUserInputSubmitted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnUserInputSubmitted_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::WebClientMode>(
    in_mode,
    &params->mode);

  
  mojo::internal::Serialize<::glic::mojom::PromptType>(
    in_prompt_type,
    &params->prompt_type);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnUserInputSubmitted");
#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 WebClientHandlerProxy::OnContextUploadStarted(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OnContextUploadStarted");
#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::WebClientHandler::kOnContextUploadStarted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnContextUploadStarted_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnContextUploadStarted");
#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 WebClientHandlerProxy::OnContextUploadCompleted(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OnContextUploadCompleted");
#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::WebClientHandler::kOnContextUploadCompleted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnContextUploadCompleted_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnContextUploadCompleted");
#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 WebClientHandlerProxy::OnReaction(
    MetricUserInputReactionType in_reactionType) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnReaction", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("reactionType"), in_reactionType,
                        "<value of type MetricUserInputReactionType>");
   });
#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::WebClientHandler::kOnReaction), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnReaction_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::MetricUserInputReactionType>(
    in_reactionType,
    &params->reactionType);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnReaction");
#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 WebClientHandlerProxy::OnResponseStarted(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OnResponseStarted");
#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::WebClientHandler::kOnResponseStarted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnResponseStarted_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnResponseStarted");
#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 WebClientHandlerProxy::OnResponseStopped(
    OnResponseStoppedDetailsPtr in_details) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnResponseStopped", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("details"), in_details,
                        "<value of type OnResponseStoppedDetailsPtr>");
   });
#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::WebClientHandler::kOnResponseStopped), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnResponseStopped_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->details)::BaseType> details_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::OnResponseStoppedDetailsDataView>(
    in_details,
    details_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnResponseStopped");
#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 WebClientHandlerProxy::OnSessionTerminated(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OnSessionTerminated");
#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::WebClientHandler::kOnSessionTerminated), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnSessionTerminated_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnSessionTerminated");
#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 WebClientHandlerProxy::OnTurnCompleted(
    WebClientModel in_model, ::base::TimeDelta in_duration) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnTurnCompleted", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("model"), in_model,
                        "<value of type WebClientModel>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("duration"), in_duration,
                        "<value of type ::base::TimeDelta>");
   });
#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::WebClientHandler::kOnTurnCompleted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnTurnCompleted_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::WebClientModel>(
    in_model,
    &params->model);
  mojo::internal::MessageFragment<
      typename decltype(params->duration)::BaseType> duration_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::TimeDeltaDataView>(
    in_duration,
    duration_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnTurnCompleted");
#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 WebClientHandlerProxy::OnResponseRated(
    bool in_positive) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnResponseRated", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("positive"), in_positive,
                        "<value of type bool>");
   });
#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::WebClientHandler::kOnResponseRated), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnResponseRated_Params_Data> params(
          message);
  params.Allocate();

  params->positive = in_positive;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnResponseRated");
#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 WebClientHandlerProxy::OnClosedCaptionsShown(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::OnClosedCaptionsShown");
#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::WebClientHandler::kOnClosedCaptionsShown), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnClosedCaptionsShown_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnClosedCaptionsShown");
#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 WebClientHandlerProxy::OnActionSubmitted(
    bool in_is_retry) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OnActionSubmitted", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_retry"), in_is_retry,
                        "<value of type bool>");
   });
#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::WebClientHandler::kOnActionSubmitted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OnActionSubmitted_Params_Data> params(
          message);
  params.Allocate();

  params->is_retry = in_is_retry;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OnActionSubmitted");
#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 WebClientHandlerProxy::SetSyntheticExperimentState(
    const std::string& in_trial_name, const std::string& in_group_name) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SetSyntheticExperimentState", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("trial_name"), in_trial_name,
                        "<value of type const std::string&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("group_name"), in_group_name,
                        "<value of type const std::string&>");
   });
#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::WebClientHandler::kSetSyntheticExperimentState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetSyntheticExperimentState_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->trial_name)::BaseType> trial_name_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_trial_name,
    trial_name_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->trial_name.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null trial_name in WebClientHandler.SetSyntheticExperimentState request");
  mojo::internal::MessageFragment<
      typename decltype(params->group_name)::BaseType> group_name_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_group_name,
    group_name_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetSyntheticExperimentState");
#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 WebClientHandlerProxy::OpenOsPermissionSettingsMenu(
    ::content_settings::mojom::ContentSettingsType in_type) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::OpenOsPermissionSettingsMenu", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("type"), in_type,
                        "<value of type ::content_settings::mojom::ContentSettingsType>");
   });
#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::WebClientHandler::kOpenOsPermissionSettingsMenu), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::content_settings::mojom::ContentSettingsType>(
    in_type,
    &params->type);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OpenOsPermissionSettingsMenu");
#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 WebClientHandlerProxy::GetOsMicrophonePermissionStatus(
    GetOsMicrophonePermissionStatusCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::GetOsMicrophonePermissionStatus");
#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::WebClientHandler::kGetOsMicrophonePermissionStatus), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::GetZeroStateSuggestionsForFocusedTab(
    std::optional<bool> in_is_first_run, GetZeroStateSuggestionsForFocusedTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::GetZeroStateSuggestionsForFocusedTab", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_first_run"), in_is_first_run,
                        "<value of type std::optional<bool>>");
   });
#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::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data> params(
          message);
  params.Allocate();
  params->is_first_run_$flag = in_is_first_run.has_value();
  if (in_is_first_run.has_value()) {
    params->is_first_run_$value = in_is_first_run.value();
  }

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

void WebClientHandlerProxy::MaybeRefreshUserStatus(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::MaybeRefreshUserStatus");
#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::WebClientHandler::kMaybeRefreshUserStatus), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_MaybeRefreshUserStatus_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("MaybeRefreshUserStatus");
#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 WebClientHandlerProxy::IsDebuggerAttached(
    IsDebuggerAttachedCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::IsDebuggerAttached");
#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::WebClientHandler::kIsDebuggerAttached), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_IsDebuggerAttached_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientHandlerProxy::SubscribeToPageMetadata(
    int32_t in_tab_id, const std::vector<std::string>& in_names, SubscribeToPageMetadataCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SubscribeToPageMetadata", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("names"), in_names,
                        "<value of type const std::vector<std::string>&>");
   });
#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::WebClientHandler::kSubscribeToPageMetadata), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SubscribeToPageMetadata_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->names)::BaseType>
      names_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& names_validate_params =
      mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
    in_names,
    names_fragment,
    &names_validate_params);

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

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

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

void WebClientHandlerProxy::SwitchConversation(
    ConversationInfoPtr in_info, SwitchConversationCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SwitchConversation", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("info"), in_info,
                        "<value of type ConversationInfoPtr>");
   });
#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::WebClientHandler::kSwitchConversation), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SwitchConversation_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->info)::BaseType> info_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ConversationInfoDataView>(
    in_info,
    info_fragment);

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

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

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

void WebClientHandlerProxy::RegisterConversation(
    ConversationInfoPtr in_info, RegisterConversationCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::RegisterConversation", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("info"), in_info,
                        "<value of type ConversationInfoPtr>");
   });
#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::WebClientHandler::kRegisterConversation), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_RegisterConversation_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->info)::BaseType> info_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ConversationInfoDataView>(
    in_info,
    info_fragment);

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

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

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

void WebClientHandlerProxy::SetOnboardingCompleted(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClientHandler::SetOnboardingCompleted");
#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::WebClientHandler::kSetOnboardingCompleted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetOnboardingCompleted_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetOnboardingCompleted");
#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 WebClientHandlerProxy::SubscribeToTabData(
    int32_t in_tab_id, ::mojo::PendingRemote<TabDataHandler> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SubscribeToTabData", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingRemote<TabDataHandler>>");
   });
#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::WebClientHandler::kSubscribeToTabData), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SubscribeToTabData_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::TabDataHandlerInterfaceBase>>(
    in_receiver,
    &params->receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid receiver in WebClientHandler.SubscribeToTabData request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SubscribeToTabData");
#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 WebClientHandlerProxy::SubscribeToTabFavicon(
    int32_t in_tab_id, ::mojo::PendingRemote<TabFaviconHandler> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClientHandler::SubscribeToTabFavicon", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingRemote<TabFaviconHandler>>");
   });
#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::WebClientHandler::kSubscribeToTabFavicon), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SubscribeToTabFavicon_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::TabFaviconHandlerInterfaceBase>>(
    in_receiver,
    &params->receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid receiver in WebClientHandler.SubscribeToTabFavicon request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SubscribeToTabFavicon");
#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);
}
class WebClientHandler_WebClientCreated_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::WebClientCreatedCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_WebClientCreated_ProxyToResponder> proxy(
        new WebClientHandler_WebClientCreated_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_WebClientCreated_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_WebClientCreated_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:
  WebClientHandler_WebClientCreated_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)
        << "WebClientHandler::WebClientCreatedCallback 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(
      WebClientInitialStatePtr in_initial_state);
};

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

  // Validation for WebClientHandler.0
  bool success = true;
  WebClientInitialStatePtr p_initial_state{};
  WebClientHandler_WebClientCreated_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadInitialState(&p_initial_state))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_initial_state));
  }
  return true;
}

void WebClientHandler_WebClientCreated_ProxyToResponder::Run(
    WebClientInitialStatePtr in_initial_state) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::WebClientCreated", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("initial_state"), in_initial_state,
                        "<value of type WebClientInitialStatePtr>");
   });
#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::WebClientHandler::kWebClientCreated), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_WebClientCreated_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->initial_state)::BaseType> initial_state_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::WebClientInitialStateDataView>(
    in_initial_state,
    initial_state_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("WebClientCreated");
#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 WebClientHandler_CreateTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::CreateTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_CreateTab_ProxyToResponder> proxy(
        new WebClientHandler_CreateTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_CreateTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_CreateTab_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:
  WebClientHandler_CreateTab_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)
        << "WebClientHandler::CreateTabCallback 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(
      TabDataPtr in_tab_data);
};

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

  // Validation for WebClientHandler.8
  bool success = true;
  TabDataPtr p_tab_data{};
  WebClientHandler_CreateTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadTabData(&p_tab_data))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 8, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_tab_data));
  }
  return true;
}

void WebClientHandler_CreateTab_ProxyToResponder::Run(
    TabDataPtr in_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::CreateTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_data"), in_tab_data,
                        "<value of type TabDataPtr>");
   });
#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::WebClientHandler::kCreateTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CreateTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_data)::BaseType> tab_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabDataDataView>(
    in_tab_data,
    tab_data_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CreateTab");
#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 WebClientHandler_ActivateTabWithUrl_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::ActivateTabWithUrlCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_ActivateTabWithUrl_ProxyToResponder> proxy(
        new WebClientHandler_ActivateTabWithUrl_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_ActivateTabWithUrl_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_ActivateTabWithUrl_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:
  WebClientHandler_ActivateTabWithUrl_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)
        << "WebClientHandler::ActivateTabWithUrlCallback 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(
      TabDataPtr in_tab_data);
};

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

  // Validation for WebClientHandler.9
  bool success = true;
  TabDataPtr p_tab_data{};
  WebClientHandler_ActivateTabWithUrl_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadTabData(&p_tab_data))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 9, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_tab_data));
  }
  return true;
}

void WebClientHandler_ActivateTabWithUrl_ProxyToResponder::Run(
    TabDataPtr in_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::ActivateTabWithUrl", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_data"), in_tab_data,
                        "<value of type TabDataPtr>");
   });
#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::WebClientHandler::kActivateTabWithUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ActivateTabWithUrl_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_data)::BaseType> tab_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabDataDataView>(
    in_tab_data,
    tab_data_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ActivateTabWithUrl");
#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 WebClientHandler_GetModelQualityClientId_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetModelQualityClientIdCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetModelQualityClientId_ProxyToResponder> proxy(
        new WebClientHandler_GetModelQualityClientId_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetModelQualityClientId_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetModelQualityClientId_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:
  WebClientHandler_GetModelQualityClientId_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)
        << "WebClientHandler::GetModelQualityClientIdCallback 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 std::string& in_model_quality_client_id);
};

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

  // Validation for WebClientHandler.21
  bool success = true;
  std::string p_model_quality_client_id{};
  WebClientHandler_GetModelQualityClientId_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadModelQualityClientId(&p_model_quality_client_id))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 21, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_model_quality_client_id));
  }
  return true;
}

void WebClientHandler_GetModelQualityClientId_ProxyToResponder::Run(
    const std::string& in_model_quality_client_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetModelQualityClientId", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("model_quality_client_id"), in_model_quality_client_id,
                        "<value of type const std::string&>");
   });
#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::WebClientHandler::kGetModelQualityClientId), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetModelQualityClientId_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->model_quality_client_id)::BaseType> model_quality_client_id_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_model_quality_client_id,
    model_quality_client_id_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetModelQualityClientId");
#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 WebClientHandler_GetContextFromFocusedTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetContextFromFocusedTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetContextFromFocusedTab_ProxyToResponder> proxy(
        new WebClientHandler_GetContextFromFocusedTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetContextFromFocusedTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetContextFromFocusedTab_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:
  WebClientHandler_GetContextFromFocusedTab_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)
        << "WebClientHandler::GetContextFromFocusedTabCallback 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(
      GetContextResultPtr in_result);
};

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

  // Validation for WebClientHandler.22
  bool success = true;
  GetContextResultPtr p_result{};
  WebClientHandler_GetContextFromFocusedTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 22, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void WebClientHandler_GetContextFromFocusedTab_ProxyToResponder::Run(
    GetContextResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetContextFromFocusedTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type GetContextResultPtr>");
   });
#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::WebClientHandler::kGetContextFromFocusedTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::GetContextResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetContextFromFocusedTab");
#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 WebClientHandler_GetContextFromTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetContextFromTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetContextFromTab_ProxyToResponder> proxy(
        new WebClientHandler_GetContextFromTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetContextFromTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetContextFromTab_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:
  WebClientHandler_GetContextFromTab_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)
        << "WebClientHandler::GetContextFromTabCallback 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(
      GetContextResultPtr in_result);
};

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

  // Validation for WebClientHandler.23
  bool success = true;
  GetContextResultPtr p_result{};
  WebClientHandler_GetContextFromTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 23, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void WebClientHandler_GetContextFromTab_ProxyToResponder::Run(
    GetContextResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetContextFromTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type GetContextResultPtr>");
   });
#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::WebClientHandler::kGetContextFromTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetContextFromTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::GetContextResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetContextFromTab");
#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 WebClientHandler_GetImageBytesFromTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetImageBytesFromTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetImageBytesFromTab_ProxyToResponder> proxy(
        new WebClientHandler_GetImageBytesFromTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetImageBytesFromTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetImageBytesFromTab_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:
  WebClientHandler_GetImageBytesFromTab_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)
        << "WebClientHandler::GetImageBytesFromTabCallback 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(
      GetImageBytesResultPtr in_result);
};

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

  // Validation for WebClientHandler.24
  bool success = true;
  GetImageBytesResultPtr p_result{};
  WebClientHandler_GetImageBytesFromTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 24, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void WebClientHandler_GetImageBytesFromTab_ProxyToResponder::Run(
    GetImageBytesResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetImageBytesFromTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type GetImageBytesResultPtr>");
   });
#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::WebClientHandler::kGetImageBytesFromTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetImageBytesFromTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::GetImageBytesResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetImageBytesFromTab");
#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 WebClientHandler_SetMaximumNumberOfPinnedTabs_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetMaximumNumberOfPinnedTabsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetMaximumNumberOfPinnedTabs_ProxyToResponder> proxy(
        new WebClientHandler_SetMaximumNumberOfPinnedTabs_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetMaximumNumberOfPinnedTabs_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetMaximumNumberOfPinnedTabs_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:
  WebClientHandler_SetMaximumNumberOfPinnedTabs_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)
        << "WebClientHandler::SetMaximumNumberOfPinnedTabsCallback 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(
      uint32_t in_effective_max);
};

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

  // Validation for WebClientHandler.25
  bool success = true;
  uint32_t p_effective_max{};
  WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_effective_max = input_data_view.effective_max();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 25, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_effective_max));
  }
  return true;
}

void WebClientHandler_SetMaximumNumberOfPinnedTabs_ProxyToResponder::Run(
    uint32_t in_effective_max) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::SetMaximumNumberOfPinnedTabs", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("effective_max"), in_effective_max,
                        "<value of type uint32_t>");
   });
#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::WebClientHandler::kSetMaximumNumberOfPinnedTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->effective_max = in_effective_max;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetMaximumNumberOfPinnedTabs");
#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 WebClientHandler_PinTabs_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::PinTabsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_PinTabs_ProxyToResponder> proxy(
        new WebClientHandler_PinTabs_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_PinTabs_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_PinTabs_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:
  WebClientHandler_PinTabs_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)
        << "WebClientHandler::PinTabsCallback 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 in_pinned_all);
};

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

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

void WebClientHandler_PinTabs_ProxyToResponder::Run(
    bool in_pinned_all) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::PinTabs", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("pinned_all"), in_pinned_all,
                        "<value of type bool>");
   });
#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::WebClientHandler::kPinTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_PinTabs_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->pinned_all = in_pinned_all;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("PinTabs");
#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 WebClientHandler_UnpinTabs_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::UnpinTabsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_UnpinTabs_ProxyToResponder> proxy(
        new WebClientHandler_UnpinTabs_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_UnpinTabs_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_UnpinTabs_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:
  WebClientHandler_UnpinTabs_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)
        << "WebClientHandler::UnpinTabsCallback 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 in_unpinned_all);
};

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

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

void WebClientHandler_UnpinTabs_ProxyToResponder::Run(
    bool in_unpinned_all) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::UnpinTabs", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("unpinned_all"), in_unpinned_all,
                        "<value of type bool>");
   });
#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::WebClientHandler::kUnpinTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_UnpinTabs_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->unpinned_all = in_unpinned_all;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("UnpinTabs");
#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 WebClientHandler_OpenPinnedTabPicker_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::OpenPinnedTabPickerCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_OpenPinnedTabPicker_ProxyToResponder> proxy(
        new WebClientHandler_OpenPinnedTabPicker_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_OpenPinnedTabPicker_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_OpenPinnedTabPicker_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:
  WebClientHandler_OpenPinnedTabPicker_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)
        << "WebClientHandler::OpenPinnedTabPickerCallback 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 WebClientHandler_OpenPinnedTabPicker_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_OpenPinnedTabPicker_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::OpenPinnedTabPicker");
#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::WebClientHandler::kOpenPinnedTabPicker), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("OpenPinnedTabPicker");
#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 WebClientHandler_ResizeWidget_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::ResizeWidgetCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_ResizeWidget_ProxyToResponder> proxy(
        new WebClientHandler_ResizeWidget_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_ResizeWidget_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_ResizeWidget_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:
  WebClientHandler_ResizeWidget_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)
        << "WebClientHandler::ResizeWidgetCallback 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 WebClientHandler_ResizeWidget_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_ResizeWidget_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_ResizeWidget_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_ResizeWidget_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::ResizeWidget");
#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::WebClientHandler::kResizeWidget), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ResizeWidget_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ResizeWidget");
#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 WebClientHandler_CaptureScreenshot_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::CaptureScreenshotCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_CaptureScreenshot_ProxyToResponder> proxy(
        new WebClientHandler_CaptureScreenshot_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_CaptureScreenshot_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_CaptureScreenshot_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:
  WebClientHandler_CaptureScreenshot_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)
        << "WebClientHandler::CaptureScreenshotCallback 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(
      CaptureScreenshotResultPtr in_result);
};

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

  // Validation for WebClientHandler.33
  bool success = true;
  CaptureScreenshotResultPtr p_result{};
  WebClientHandler_CaptureScreenshot_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 33, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void WebClientHandler_CaptureScreenshot_ProxyToResponder::Run(
    CaptureScreenshotResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::CaptureScreenshot", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type CaptureScreenshotResultPtr>");
   });
#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::WebClientHandler::kCaptureScreenshot), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_CaptureScreenshot_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::glic::mojom::CaptureScreenshotResultDataView>(
    in_result,
    result_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("CaptureScreenshot");
#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 WebClientHandler_SetAudioDucking_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetAudioDuckingCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetAudioDucking_ProxyToResponder> proxy(
        new WebClientHandler_SetAudioDucking_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetAudioDucking_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetAudioDucking_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:
  WebClientHandler_SetAudioDucking_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)
        << "WebClientHandler::SetAudioDuckingCallback 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 in_result);
};

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

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

void WebClientHandler_SetAudioDucking_ProxyToResponder::Run(
    bool in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::SetAudioDucking", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSetAudioDucking), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetAudioDucking_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->result = in_result;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetAudioDucking");
#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 WebClientHandler_SetMicrophonePermissionState_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetMicrophonePermissionStateCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetMicrophonePermissionState_ProxyToResponder> proxy(
        new WebClientHandler_SetMicrophonePermissionState_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetMicrophonePermissionState_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetMicrophonePermissionState_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:
  WebClientHandler_SetMicrophonePermissionState_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)
        << "WebClientHandler::SetMicrophonePermissionStateCallback 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 WebClientHandler_SetMicrophonePermissionState_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_SetMicrophonePermissionState_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::SetMicrophonePermissionState");
#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::WebClientHandler::kSetMicrophonePermissionState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetMicrophonePermissionState");
#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 WebClientHandler_SetLocationPermissionState_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetLocationPermissionStateCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetLocationPermissionState_ProxyToResponder> proxy(
        new WebClientHandler_SetLocationPermissionState_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetLocationPermissionState_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetLocationPermissionState_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:
  WebClientHandler_SetLocationPermissionState_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)
        << "WebClientHandler::SetLocationPermissionStateCallback 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 WebClientHandler_SetLocationPermissionState_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_SetLocationPermissionState_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_SetLocationPermissionState_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_SetLocationPermissionState_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::SetLocationPermissionState");
#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::WebClientHandler::kSetLocationPermissionState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetLocationPermissionState_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetLocationPermissionState");
#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 WebClientHandler_SetTabContextPermissionState_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetTabContextPermissionStateCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetTabContextPermissionState_ProxyToResponder> proxy(
        new WebClientHandler_SetTabContextPermissionState_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetTabContextPermissionState_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetTabContextPermissionState_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:
  WebClientHandler_SetTabContextPermissionState_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)
        << "WebClientHandler::SetTabContextPermissionStateCallback 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 WebClientHandler_SetTabContextPermissionState_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_SetTabContextPermissionState_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_SetTabContextPermissionState_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_SetTabContextPermissionState_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::SetTabContextPermissionState");
#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::WebClientHandler::kSetTabContextPermissionState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetTabContextPermissionState_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetTabContextPermissionState");
#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 WebClientHandler_SetClosedCaptioningSetting_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetClosedCaptioningSettingCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetClosedCaptioningSetting_ProxyToResponder> proxy(
        new WebClientHandler_SetClosedCaptioningSetting_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetClosedCaptioningSetting_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetClosedCaptioningSetting_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:
  WebClientHandler_SetClosedCaptioningSetting_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)
        << "WebClientHandler::SetClosedCaptioningSettingCallback 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 WebClientHandler_SetClosedCaptioningSetting_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_SetClosedCaptioningSetting_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::SetClosedCaptioningSetting");
#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::WebClientHandler::kSetClosedCaptioningSetting), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetClosedCaptioningSetting");
#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 WebClientHandler_SetActuationOnWebSetting_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SetActuationOnWebSettingCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SetActuationOnWebSetting_ProxyToResponder> proxy(
        new WebClientHandler_SetActuationOnWebSetting_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SetActuationOnWebSetting_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SetActuationOnWebSetting_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:
  WebClientHandler_SetActuationOnWebSetting_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)
        << "WebClientHandler::SetActuationOnWebSettingCallback 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 WebClientHandler_SetActuationOnWebSetting_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClientHandler_SetActuationOnWebSetting_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClientHandler::SetActuationOnWebSetting");
#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::WebClientHandler::kSetActuationOnWebSetting), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SetActuationOnWebSetting");
#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 WebClientHandler_ShouldAllowMediaPermissionRequest_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::ShouldAllowMediaPermissionRequestCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_ShouldAllowMediaPermissionRequest_ProxyToResponder> proxy(
        new WebClientHandler_ShouldAllowMediaPermissionRequest_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_ShouldAllowMediaPermissionRequest_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_ShouldAllowMediaPermissionRequest_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:
  WebClientHandler_ShouldAllowMediaPermissionRequest_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)
        << "WebClientHandler::ShouldAllowMediaPermissionRequestCallback 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 in_is_allowed);
};

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

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

void WebClientHandler_ShouldAllowMediaPermissionRequest_ProxyToResponder::Run(
    bool in_is_allowed) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::ShouldAllowMediaPermissionRequest", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_allowed"), in_is_allowed,
                        "<value of type bool>");
   });
#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::WebClientHandler::kShouldAllowMediaPermissionRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_allowed = in_is_allowed;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ShouldAllowMediaPermissionRequest");
#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 WebClientHandler_ShouldAllowGeolocationPermissionRequest_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::ShouldAllowGeolocationPermissionRequestCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_ShouldAllowGeolocationPermissionRequest_ProxyToResponder> proxy(
        new WebClientHandler_ShouldAllowGeolocationPermissionRequest_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_ShouldAllowGeolocationPermissionRequest_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_ShouldAllowGeolocationPermissionRequest_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:
  WebClientHandler_ShouldAllowGeolocationPermissionRequest_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)
        << "WebClientHandler::ShouldAllowGeolocationPermissionRequestCallback 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 in_is_allowed);
};

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

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

void WebClientHandler_ShouldAllowGeolocationPermissionRequest_ProxyToResponder::Run(
    bool in_is_allowed) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::ShouldAllowGeolocationPermissionRequest", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_allowed"), in_is_allowed,
                        "<value of type bool>");
   });
#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::WebClientHandler::kShouldAllowGeolocationPermissionRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_allowed = in_is_allowed;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("ShouldAllowGeolocationPermissionRequest");
#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 WebClientHandler_GetUserProfileInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetUserProfileInfoCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetUserProfileInfo_ProxyToResponder> proxy(
        new WebClientHandler_GetUserProfileInfo_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetUserProfileInfo_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetUserProfileInfo_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:
  WebClientHandler_GetUserProfileInfo_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)
        << "WebClientHandler::GetUserProfileInfoCallback 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(
      UserProfileInfoPtr in_profile_info);
};

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

  // Validation for WebClientHandler.46
  bool success = true;
  UserProfileInfoPtr p_profile_info{};
  WebClientHandler_GetUserProfileInfo_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadProfileInfo(&p_profile_info))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 46, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_profile_info));
  }
  return true;
}

void WebClientHandler_GetUserProfileInfo_ProxyToResponder::Run(
    UserProfileInfoPtr in_profile_info) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetUserProfileInfo", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("profile_info"), in_profile_info,
                        "<value of type UserProfileInfoPtr>");
   });
#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::WebClientHandler::kGetUserProfileInfo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetUserProfileInfo_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->profile_info)::BaseType> profile_info_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::UserProfileInfoDataView>(
    in_profile_info,
    profile_info_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetUserProfileInfo");
#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 WebClientHandler_SyncCookies_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SyncCookiesCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SyncCookies_ProxyToResponder> proxy(
        new WebClientHandler_SyncCookies_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SyncCookies_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SyncCookies_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:
  WebClientHandler_SyncCookies_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)
        << "WebClientHandler::SyncCookiesCallback 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 in_success);
};

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

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

void WebClientHandler_SyncCookies_ProxyToResponder::Run(
    bool in_success) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::SyncCookies", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSyncCookies), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SyncCookies_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SyncCookies");
#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 WebClientHandler_GetOsMicrophonePermissionStatus_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetOsMicrophonePermissionStatusCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetOsMicrophonePermissionStatus_ProxyToResponder> proxy(
        new WebClientHandler_GetOsMicrophonePermissionStatus_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetOsMicrophonePermissionStatus_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetOsMicrophonePermissionStatus_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:
  WebClientHandler_GetOsMicrophonePermissionStatus_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)
        << "WebClientHandler::GetOsMicrophonePermissionStatusCallback 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 in_enabled);
};

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

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

void WebClientHandler_GetOsMicrophonePermissionStatus_ProxyToResponder::Run(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetOsMicrophonePermissionStatus", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClientHandler::kGetOsMicrophonePermissionStatus), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetOsMicrophonePermissionStatus");
#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 WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::GetZeroStateSuggestionsForFocusedTabCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ProxyToResponder> proxy(
        new WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_GetZeroStateSuggestionsForFocusedTab_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:
  WebClientHandler_GetZeroStateSuggestionsForFocusedTab_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)
        << "WebClientHandler::GetZeroStateSuggestionsForFocusedTabCallback 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(
      ZeroStateSuggestionsPtr in_suggestions);
};

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

  // Validation for WebClientHandler.66
  bool success = true;
  ZeroStateSuggestionsPtr p_suggestions{};
  WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadSuggestions(&p_suggestions))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 66, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_suggestions));
  }
  return true;
}

void WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ProxyToResponder::Run(
    ZeroStateSuggestionsPtr in_suggestions) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::GetZeroStateSuggestionsForFocusedTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("suggestions"), in_suggestions,
                        "<value of type ZeroStateSuggestionsPtr>");
   });
#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::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->suggestions)::BaseType> suggestions_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ZeroStateSuggestionsDataView>(
    in_suggestions,
    suggestions_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("GetZeroStateSuggestionsForFocusedTab");
#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 WebClientHandler_IsDebuggerAttached_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::IsDebuggerAttachedCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_IsDebuggerAttached_ProxyToResponder> proxy(
        new WebClientHandler_IsDebuggerAttached_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_IsDebuggerAttached_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_IsDebuggerAttached_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:
  WebClientHandler_IsDebuggerAttached_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)
        << "WebClientHandler::IsDebuggerAttachedCallback 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 in_is_attached_to_webview);
};

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

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

void WebClientHandler_IsDebuggerAttached_ProxyToResponder::Run(
    bool in_is_attached_to_webview) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::IsDebuggerAttached", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_attached_to_webview"), in_is_attached_to_webview,
                        "<value of type bool>");
   });
#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::WebClientHandler::kIsDebuggerAttached), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_IsDebuggerAttached_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_attached_to_webview = in_is_attached_to_webview;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("IsDebuggerAttached");
#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 WebClientHandler_SubscribeToPageMetadata_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SubscribeToPageMetadataCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SubscribeToPageMetadata_ProxyToResponder> proxy(
        new WebClientHandler_SubscribeToPageMetadata_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SubscribeToPageMetadata_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SubscribeToPageMetadata_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:
  WebClientHandler_SubscribeToPageMetadata_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)
        << "WebClientHandler::SubscribeToPageMetadataCallback 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 in_success);
};

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

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

void WebClientHandler_SubscribeToPageMetadata_ProxyToResponder::Run(
    bool in_success) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::SubscribeToPageMetadata", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
   });
#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::WebClientHandler::kSubscribeToPageMetadata), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SubscribeToPageMetadata");
#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 WebClientHandler_SwitchConversation_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::SwitchConversationCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_SwitchConversation_ProxyToResponder> proxy(
        new WebClientHandler_SwitchConversation_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_SwitchConversation_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_SwitchConversation_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:
  WebClientHandler_SwitchConversation_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)
        << "WebClientHandler::SwitchConversationCallback 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(
      std::optional<SwitchConversationErrorReason> in_error_reason);
};

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

  // Validation for WebClientHandler.70
  bool success = true;
  std::optional<SwitchConversationErrorReason> p_error_reason{};
  WebClientHandler_SwitchConversation_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadErrorReason(&p_error_reason)) {
    success = false;
  }
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 70, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_error_reason));
  }
  return true;
}

void WebClientHandler_SwitchConversation_ProxyToResponder::Run(
    std::optional<SwitchConversationErrorReason> in_error_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::SwitchConversation", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("error_reason"), in_error_reason,
                        "<value of type std::optional<SwitchConversationErrorReason>>");
   });
#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::WebClientHandler::kSwitchConversation), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_SwitchConversation_ResponseParams_Data> params(
          message);
  params.Allocate();
  params->error_reason_$flag = in_error_reason.has_value();
  if (in_error_reason.has_value()) {
    
    mojo::internal::Serialize<::glic::mojom::SwitchConversationErrorReason>(
      in_error_reason.value(),
      &params->error_reason_$value);
  } else {
    params->error_reason_$value =
        static_cast<int32_t>(::glic::mojom::SwitchConversationErrorReason::kMinValue);
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("SwitchConversation");
#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 WebClientHandler_RegisterConversation_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClientHandler::RegisterConversationCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClientHandler_RegisterConversation_ProxyToResponder> proxy(
        new WebClientHandler_RegisterConversation_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClientHandler_RegisterConversation_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClientHandler_RegisterConversation_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:
  WebClientHandler_RegisterConversation_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)
        << "WebClientHandler::RegisterConversationCallback 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(
      std::optional<RegisterConversationErrorReason> in_error_reason);
};

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

  // Validation for WebClientHandler.71
  bool success = true;
  std::optional<RegisterConversationErrorReason> p_error_reason{};
  WebClientHandler_RegisterConversation_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadErrorReason(&p_error_reason)) {
    success = false;
  }
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClientHandler::Name_, 71, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_error_reason));
  }
  return true;
}

void WebClientHandler_RegisterConversation_ProxyToResponder::Run(
    std::optional<RegisterConversationErrorReason> in_error_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClientHandler::RegisterConversation", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("error_reason"), in_error_reason,
                        "<value of type std::optional<RegisterConversationErrorReason>>");
   });
#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::WebClientHandler::kRegisterConversation), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClientHandler_RegisterConversation_ResponseParams_Data> params(
          message);
  params.Allocate();
  params->error_reason_$flag = in_error_reason.has_value();
  if (in_error_reason.has_value()) {
    
    mojo::internal::Serialize<::glic::mojom::RegisterConversationErrorReason>(
      in_error_reason.value(),
      &params->error_reason_$value);
  } else {
    params->error_reason_$value =
        static_cast<int32_t>(::glic::mojom::RegisterConversationErrorReason::kMinValue);
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClientHandler::Name_);
  message.set_method_name("RegisterConversation");
#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 WebClientHandlerStubDispatch::Accept(
    WebClientHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::WebClientHandler>(message->header()->name)) {
    case messages::WebClientHandler::kWebClientCreated: {
      break;
    }
    case messages::WebClientHandler::kWebClientInitialized: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_WebClientInitialized_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_WebClientInitialized_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.1
      bool success = true;
      WebClientHandler_WebClientInitialized_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->WebClientInitialized(        );
      return true;
    }
    case messages::WebClientHandler::kWebClientInitializeFailed: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_WebClientInitializeFailed_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_WebClientInitializeFailed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.2
      bool success = true;
      WebClientHandler_WebClientInitializeFailed_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->WebClientInitializeFailed(        );
      return true;
    }
    case messages::WebClientHandler::kCreateActorHandler: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_CreateActorHandler_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_CreateActorHandler_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.3
      bool success = true;
      ::mojo::PendingReceiver<ActorHandler> p_receiver{};
      ::mojo::PendingRemote<ActorClient> p_client{};
      WebClientHandler_CreateActorHandler_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (success) {
        p_client =
            input_data_view.TakeClient<decltype(p_client)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateActorHandler(        
        std::move(p_receiver), 
        std::move(p_client));
      return true;
    }
    case messages::WebClientHandler::kCreateExperimentalTriggeringClient: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_CreateExperimentalTriggeringClient_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_CreateExperimentalTriggeringClient_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.4
      bool success = true;
      ::mojo::PendingRemote<ExperimentalTriggeringClient> p_client{};
      WebClientHandler_CreateExperimentalTriggeringClient_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_client =
            input_data_view.TakeClient<decltype(p_client)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateExperimentalTriggeringClient(        
        std::move(p_client));
      return true;
    }
    case messages::WebClientHandler::kCreateAnnotationHandler: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_CreateAnnotationHandler_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_CreateAnnotationHandler_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.5
      bool success = true;
      ::mojo::PendingReceiver<AnnotationHandler> p_receiver{};
      WebClientHandler_CreateAnnotationHandler_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 5, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateAnnotationHandler(        
        std::move(p_receiver));
      return true;
    }
    case messages::WebClientHandler::kCreateSkillsHandler: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_CreateSkillsHandler_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_CreateSkillsHandler_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.6
      bool success = true;
      ::mojo::PendingReceiver<SkillsHandler> p_receiver{};
      ::mojo::PendingRemote<SkillsClient> p_client{};
      WebClientHandler_CreateSkillsHandler_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (success) {
        p_client =
            input_data_view.TakeClient<decltype(p_client)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 6, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateSkillsHandler(        
        std::move(p_receiver), 
        std::move(p_client));
      return true;
    }
    case messages::WebClientHandler::kCreateZeroStateSuggestionsHandler: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.7
      bool success = true;
      ::mojo::PendingReceiver<ZeroStateSuggestionsHandler> p_receiver{};
      WebClientHandler_CreateZeroStateSuggestionsHandler_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 7, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateZeroStateSuggestionsHandler(        
        std::move(p_receiver));
      return true;
    }
    case messages::WebClientHandler::kCreateTab: {
      break;
    }
    case messages::WebClientHandler::kActivateTabWithUrl: {
      break;
    }
    case messages::WebClientHandler::kOpenLinkInPopup: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OpenLinkInPopup_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OpenLinkInPopup_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.10
      bool success = true;
      ::GURL p_url{};
      int32_t p_popup_width{};
      int32_t p_popup_height{};
      WebClientHandler_OpenLinkInPopup_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (success)
        p_popup_width = input_data_view.popup_width();
      if (success)
        p_popup_height = input_data_view.popup_height();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 10, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenLinkInPopup(        
        std::move(p_url), 
        std::move(p_popup_width), 
        std::move(p_popup_height));
      return true;
    }
    case messages::WebClientHandler::kOpenGlicSettingsPage: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OpenGlicSettingsPage_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OpenGlicSettingsPage_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.11
      bool success = true;
      OpenSettingsOptionsPtr p_options{};
      WebClientHandler_OpenGlicSettingsPage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 11, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenGlicSettingsPage(        
        std::move(p_options));
      return true;
    }
    case messages::WebClientHandler::kOpenPasswordManagerSettingsPage: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.12
      bool success = true;
      WebClientHandler_OpenPasswordManagerSettingsPage_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 12, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenPasswordManagerSettingsPage(        );
      return true;
    }
    case messages::WebClientHandler::kEnableDragResize: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_EnableDragResize_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_EnableDragResize_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.13
      bool success = true;
      bool p_enabled{};
      WebClientHandler_EnableDragResize_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 13, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->EnableDragResize(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClientHandler::kClosePanel: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ClosePanel_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ClosePanel_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.14
      bool success = true;
      WebClientHandler_ClosePanel_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 14, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ClosePanel(        );
      return true;
    }
    case messages::WebClientHandler::kClosePanelAndShutdown: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ClosePanelAndShutdown_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ClosePanelAndShutdown_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.15
      bool success = true;
      WebClientHandler_ClosePanelAndShutdown_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 15, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ClosePanelAndShutdown(        );
      return true;
    }
    case messages::WebClientHandler::kAttachPanel: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_AttachPanel_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_AttachPanel_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.16
      bool success = true;
      WebClientHandler_AttachPanel_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 16, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AttachPanel(        );
      return true;
    }
    case messages::WebClientHandler::kDetachPanel: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_DetachPanel_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_DetachPanel_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.17
      bool success = true;
      WebClientHandler_DetachPanel_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 17, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DetachPanel(        );
      return true;
    }
    case messages::WebClientHandler::kOnModeChange: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnModeChange_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnModeChange_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.18
      bool success = true;
      WebClientMode p_new_mode{};
      WebClientHandler_OnModeChange_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadNewMode(&p_new_mode))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 18, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnModeChange(        
        std::move(p_new_mode));
      return true;
    }
    case messages::WebClientHandler::kOnMicrophoneStatusChange: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnMicrophoneStatusChange_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnMicrophoneStatusChange_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.19
      bool success = true;
      MicrophoneStatus p_status{};
      WebClientHandler_OnMicrophoneStatusChange_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadStatus(&p_status))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 19, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnMicrophoneStatusChange(        
        std::move(p_status));
      return true;
    }
    case messages::WebClientHandler::kShowProfilePicker: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ShowProfilePicker_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ShowProfilePicker_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.20
      bool success = true;
      WebClientHandler_ShowProfilePicker_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 20, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowProfilePicker(        );
      return true;
    }
    case messages::WebClientHandler::kGetModelQualityClientId: {
      break;
    }
    case messages::WebClientHandler::kGetContextFromFocusedTab: {
      break;
    }
    case messages::WebClientHandler::kGetContextFromTab: {
      break;
    }
    case messages::WebClientHandler::kGetImageBytesFromTab: {
      break;
    }
    case messages::WebClientHandler::kSetMaximumNumberOfPinnedTabs: {
      break;
    }
    case messages::WebClientHandler::kPinTabs: {
      break;
    }
    case messages::WebClientHandler::kUnpinTabs: {
      break;
    }
    case messages::WebClientHandler::kUnpinAllTabs: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_UnpinAllTabs_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_UnpinAllTabs_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.28
      bool success = true;
      UnpinTabsOptionsPtr p_options{};
      WebClientHandler_UnpinAllTabs_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 28, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UnpinAllTabs(        
        std::move(p_options));
      return true;
    }
    case messages::WebClientHandler::kSubscribeToPinCandidates: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SubscribeToPinCandidates_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SubscribeToPinCandidates_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.29
      bool success = true;
      GetPinCandidatesOptionsPtr p_options{};
      ::mojo::PendingRemote<PinCandidatesObserver> p_observer{};
      WebClientHandler_SubscribeToPinCandidates_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (success) {
        p_observer =
            input_data_view.TakeObserver<decltype(p_observer)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 29, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SubscribeToPinCandidates(        
        std::move(p_options), 
        std::move(p_observer));
      return true;
    }
    case messages::WebClientHandler::kOpenPinnedTabPicker: {
      break;
    }
    case messages::WebClientHandler::kActivateTab: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ActivateTab_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ActivateTab_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.31
      bool success = true;
      int32_t p_task_id{};
      WebClientHandler_ActivateTab_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 31, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ActivateTab(        
        std::move(p_task_id));
      return true;
    }
    case messages::WebClientHandler::kResizeWidget: {
      break;
    }
    case messages::WebClientHandler::kCaptureScreenshot: {
      break;
    }
    case messages::WebClientHandler::kCaptureRegion: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_CaptureRegion_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_CaptureRegion_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.34
      bool success = true;
      ::mojo::PendingRemote<CaptureRegionObserver> p_observer{};
      CaptureRegionParamsPtr p_params{};
      WebClientHandler_CaptureRegion_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_observer =
            input_data_view.TakeObserver<decltype(p_observer)>();
      }
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 34, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CaptureRegion(        
        std::move(p_observer), 
        std::move(p_params));
      return true;
    }
    case messages::WebClientHandler::kDeleteCapturedRegion: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_DeleteCapturedRegion_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_DeleteCapturedRegion_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.35
      bool success = true;
      int32_t p_tab_id{};
      ::base::UnguessableToken p_id{};
      WebClientHandler_DeleteCapturedRegion_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadId(&p_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 35, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DeleteCapturedRegion(        
        std::move(p_tab_id), 
        std::move(p_id));
      return true;
    }
    case messages::WebClientHandler::kSetAudioDucking: {
      break;
    }
    case messages::WebClientHandler::kSetMinimumPanelSize: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SetMinimumPanelSize_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SetMinimumPanelSize_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.37
      bool success = true;
      ::gfx::Size p_size{};
      WebClientHandler_SetMinimumPanelSize_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSize(&p_size))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 37, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetMinimumPanelSize(        
        std::move(p_size));
      return true;
    }
    case messages::WebClientHandler::kSetMicrophonePermissionState: {
      break;
    }
    case messages::WebClientHandler::kSetLocationPermissionState: {
      break;
    }
    case messages::WebClientHandler::kSetTabContextPermissionState: {
      break;
    }
    case messages::WebClientHandler::kSetClosedCaptioningSetting: {
      break;
    }
    case messages::WebClientHandler::kSetActuationOnWebSetting: {
      break;
    }
    case messages::WebClientHandler::kShouldAllowMediaPermissionRequest: {
      break;
    }
    case messages::WebClientHandler::kShouldAllowGeolocationPermissionRequest: {
      break;
    }
    case messages::WebClientHandler::kSetContextAccessIndicator: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SetContextAccessIndicator_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SetContextAccessIndicator_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.45
      bool success = true;
      bool p_enabled{};
      WebClientHandler_SetContextAccessIndicator_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 45, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetContextAccessIndicator(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClientHandler::kGetUserProfileInfo: {
      break;
    }
    case messages::WebClientHandler::kSyncCookies: {
      break;
    }
    case messages::WebClientHandler::kClientErrorDialogStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ClientErrorDialogStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ClientErrorDialogStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.48
      bool success = true;
      std::optional<ClientErrorDialogType> p_shown_dialog_type{};
      WebClientHandler_ClientErrorDialogStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadShownDialogType(&p_shown_dialog_type)) {
        success = false;
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 48, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ClientErrorDialogStateChanged(        
        std::move(p_shown_dialog_type));
      return true;
    }
    case messages::WebClientHandler::kReportClientTransientError: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ReportClientTransientError_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ReportClientTransientError_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.49
      bool success = true;
      ::mojo_base::mojom::AbslStatusCode p_status_code{};
      WebClientHandler_ReportClientTransientError_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadStatusCode(&p_status_code))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 49, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ReportClientTransientError(        
        std::move(p_status_code));
      return true;
    }
    case messages::WebClientHandler::kProcessCounterAbuseVerdict: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_ProcessCounterAbuseVerdict_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_ProcessCounterAbuseVerdict_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.50
      bool success = true;
      int32_t p_tab_id{};
      CounterAbuseVerdictPtr p_verdict{};
      WebClientHandler_ProcessCounterAbuseVerdict_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadVerdict(&p_verdict))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 50, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ProcessCounterAbuseVerdict(        
        std::move(p_tab_id), 
        std::move(p_verdict));
      return true;
    }
    case messages::WebClientHandler::kOnOptinImpression: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnOptinImpression_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnOptinImpression_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.51
      bool success = true;
      WebClientHandler_OnOptinImpression_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 51, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnOptinImpression(        );
      return true;
    }
    case messages::WebClientHandler::kOnUserInputSubmitted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnUserInputSubmitted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnUserInputSubmitted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.52
      bool success = true;
      WebClientMode p_mode{};
      PromptType p_prompt_type{};
      WebClientHandler_OnUserInputSubmitted_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadMode(&p_mode))
        success = false;
      if (success && !input_data_view.ReadPromptType(&p_prompt_type))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 52, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnUserInputSubmitted(        
        std::move(p_mode), 
        std::move(p_prompt_type));
      return true;
    }
    case messages::WebClientHandler::kOnContextUploadStarted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnContextUploadStarted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnContextUploadStarted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.53
      bool success = true;
      WebClientHandler_OnContextUploadStarted_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 53, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnContextUploadStarted(        );
      return true;
    }
    case messages::WebClientHandler::kOnContextUploadCompleted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnContextUploadCompleted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnContextUploadCompleted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.54
      bool success = true;
      WebClientHandler_OnContextUploadCompleted_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 54, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnContextUploadCompleted(        );
      return true;
    }
    case messages::WebClientHandler::kOnReaction: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnReaction_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnReaction_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.55
      bool success = true;
      MetricUserInputReactionType p_reactionType{};
      WebClientHandler_OnReaction_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadReactionType(&p_reactionType))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 55, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnReaction(        
        std::move(p_reactionType));
      return true;
    }
    case messages::WebClientHandler::kOnResponseStarted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnResponseStarted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnResponseStarted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.56
      bool success = true;
      WebClientHandler_OnResponseStarted_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 56, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnResponseStarted(        );
      return true;
    }
    case messages::WebClientHandler::kOnResponseStopped: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnResponseStopped_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnResponseStopped_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.57
      bool success = true;
      OnResponseStoppedDetailsPtr p_details{};
      WebClientHandler_OnResponseStopped_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadDetails(&p_details))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 57, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnResponseStopped(        
        std::move(p_details));
      return true;
    }
    case messages::WebClientHandler::kOnSessionTerminated: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnSessionTerminated_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnSessionTerminated_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.58
      bool success = true;
      WebClientHandler_OnSessionTerminated_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 58, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnSessionTerminated(        );
      return true;
    }
    case messages::WebClientHandler::kOnTurnCompleted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnTurnCompleted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnTurnCompleted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.59
      bool success = true;
      WebClientModel p_model{};
      ::base::TimeDelta p_duration{};
      WebClientHandler_OnTurnCompleted_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadModel(&p_model))
        success = false;
      if (success && !input_data_view.ReadDuration(&p_duration))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 59, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTurnCompleted(        
        std::move(p_model), 
        std::move(p_duration));
      return true;
    }
    case messages::WebClientHandler::kOnResponseRated: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnResponseRated_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnResponseRated_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.60
      bool success = true;
      bool p_positive{};
      WebClientHandler_OnResponseRated_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_positive = input_data_view.positive();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 60, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnResponseRated(        
        std::move(p_positive));
      return true;
    }
    case messages::WebClientHandler::kOnClosedCaptionsShown: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnClosedCaptionsShown_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnClosedCaptionsShown_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.61
      bool success = true;
      WebClientHandler_OnClosedCaptionsShown_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 61, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnClosedCaptionsShown(        );
      return true;
    }
    case messages::WebClientHandler::kOnActionSubmitted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OnActionSubmitted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OnActionSubmitted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.62
      bool success = true;
      bool p_is_retry{};
      WebClientHandler_OnActionSubmitted_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_retry = input_data_view.is_retry();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 62, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnActionSubmitted(        
        std::move(p_is_retry));
      return true;
    }
    case messages::WebClientHandler::kSetSyntheticExperimentState: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SetSyntheticExperimentState_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SetSyntheticExperimentState_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.63
      bool success = true;
      std::string p_trial_name{};
      std::string p_group_name{};
      WebClientHandler_SetSyntheticExperimentState_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTrialName(&p_trial_name))
        success = false;
      if (success && !input_data_view.ReadGroupName(&p_group_name))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 63, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetSyntheticExperimentState(        
        std::move(p_trial_name), 
        std::move(p_group_name));
      return true;
    }
    case messages::WebClientHandler::kOpenOsPermissionSettingsMenu: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.64
      bool success = true;
      ::content_settings::mojom::ContentSettingsType p_type{};
      WebClientHandler_OpenOsPermissionSettingsMenu_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadType(&p_type))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 64, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenOsPermissionSettingsMenu(        
        std::move(p_type));
      return true;
    }
    case messages::WebClientHandler::kGetOsMicrophonePermissionStatus: {
      break;
    }
    case messages::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab: {
      break;
    }
    case messages::WebClientHandler::kMaybeRefreshUserStatus: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_MaybeRefreshUserStatus_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_MaybeRefreshUserStatus_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.67
      bool success = true;
      WebClientHandler_MaybeRefreshUserStatus_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 67, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->MaybeRefreshUserStatus(        );
      return true;
    }
    case messages::WebClientHandler::kIsDebuggerAttached: {
      break;
    }
    case messages::WebClientHandler::kSubscribeToPageMetadata: {
      break;
    }
    case messages::WebClientHandler::kSwitchConversation: {
      break;
    }
    case messages::WebClientHandler::kRegisterConversation: {
      break;
    }
    case messages::WebClientHandler::kSetOnboardingCompleted: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SetOnboardingCompleted_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SetOnboardingCompleted_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.72
      bool success = true;
      WebClientHandler_SetOnboardingCompleted_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 72, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetOnboardingCompleted(        );
      return true;
    }
    case messages::WebClientHandler::kSubscribeToTabData: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SubscribeToTabData_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SubscribeToTabData_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.73
      bool success = true;
      int32_t p_tab_id{};
      ::mojo::PendingRemote<TabDataHandler> p_receiver{};
      WebClientHandler_SubscribeToTabData_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 73, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SubscribeToTabData(        
        std::move(p_tab_id), 
        std::move(p_receiver));
      return true;
    }
    case messages::WebClientHandler::kSubscribeToTabFavicon: {
      DCHECK(message->is_serialized());
      internal::WebClientHandler_SubscribeToTabFavicon_Params_Data* params =
          reinterpret_cast<internal::WebClientHandler_SubscribeToTabFavicon_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClientHandler.74
      bool success = true;
      int32_t p_tab_id{};
      ::mojo::PendingRemote<TabFaviconHandler> p_receiver{};
      WebClientHandler_SubscribeToTabFavicon_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 74, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SubscribeToTabFavicon(        
        std::move(p_tab_id), 
        std::move(p_receiver));
      return true;
    }
  }
  return false;
}

// static
bool WebClientHandlerStubDispatch::AcceptWithResponder(
    WebClientHandler* 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::WebClientHandler>(message->header()->name)) {
    case messages::WebClientHandler::kWebClientCreated: {
      internal::WebClientHandler_WebClientCreated_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_WebClientCreated_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.0
      bool success = true;
      ::mojo::PendingRemote<WebClient> p_web_client{};
      WebClientHandler_WebClientCreated_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_web_client =
            input_data_view.TakeWebClient<decltype(p_web_client)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          WebClientHandler_WebClientCreated_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->WebClientCreated(        
        std::move(p_web_client), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kWebClientInitialized: {
      break;
    }
    case messages::WebClientHandler::kWebClientInitializeFailed: {
      break;
    }
    case messages::WebClientHandler::kCreateActorHandler: {
      break;
    }
    case messages::WebClientHandler::kCreateExperimentalTriggeringClient: {
      break;
    }
    case messages::WebClientHandler::kCreateAnnotationHandler: {
      break;
    }
    case messages::WebClientHandler::kCreateSkillsHandler: {
      break;
    }
    case messages::WebClientHandler::kCreateZeroStateSuggestionsHandler: {
      break;
    }
    case messages::WebClientHandler::kCreateTab: {
      internal::WebClientHandler_CreateTab_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_CreateTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.8
      bool success = true;
      ::GURL p_url{};
      CreateTabOptionsPtr p_create_options{};
      WebClientHandler_CreateTab_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (success && !input_data_view.ReadCreateOptions(&p_create_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 8, false);
        return false;
      }
      auto callback =
          WebClientHandler_CreateTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateTab(        
        std::move(p_url), 
        std::move(p_create_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kActivateTabWithUrl: {
      internal::WebClientHandler_ActivateTabWithUrl_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_ActivateTabWithUrl_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.9
      bool success = true;
      ::GURL p_exact_url{};
      ActivateTabOptionsPtr p_options{};
      WebClientHandler_ActivateTabWithUrl_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadExactUrl(&p_exact_url))
        success = false;
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 9, false);
        return false;
      }
      auto callback =
          WebClientHandler_ActivateTabWithUrl_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ActivateTabWithUrl(        
        std::move(p_exact_url), 
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kOpenLinkInPopup: {
      break;
    }
    case messages::WebClientHandler::kOpenGlicSettingsPage: {
      break;
    }
    case messages::WebClientHandler::kOpenPasswordManagerSettingsPage: {
      break;
    }
    case messages::WebClientHandler::kEnableDragResize: {
      break;
    }
    case messages::WebClientHandler::kClosePanel: {
      break;
    }
    case messages::WebClientHandler::kClosePanelAndShutdown: {
      break;
    }
    case messages::WebClientHandler::kAttachPanel: {
      break;
    }
    case messages::WebClientHandler::kDetachPanel: {
      break;
    }
    case messages::WebClientHandler::kOnModeChange: {
      break;
    }
    case messages::WebClientHandler::kOnMicrophoneStatusChange: {
      break;
    }
    case messages::WebClientHandler::kShowProfilePicker: {
      break;
    }
    case messages::WebClientHandler::kGetModelQualityClientId: {
      internal::WebClientHandler_GetModelQualityClientId_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetModelQualityClientId_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.21
      bool success = true;
      WebClientHandler_GetModelQualityClientId_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 21, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetModelQualityClientId_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetModelQualityClientId(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kGetContextFromFocusedTab: {
      internal::WebClientHandler_GetContextFromFocusedTab_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetContextFromFocusedTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.22
      bool success = true;
      TabContextOptionsPtr p_options{};
      WebClientHandler_GetContextFromFocusedTab_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 22, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetContextFromFocusedTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetContextFromFocusedTab(        
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kGetContextFromTab: {
      internal::WebClientHandler_GetContextFromTab_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetContextFromTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.23
      bool success = true;
      int32_t p_tab_id{};
      TabContextOptionsPtr p_options{};
      WebClientHandler_GetContextFromTab_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 23, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetContextFromTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetContextFromTab(        
        std::move(p_tab_id), 
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kGetImageBytesFromTab: {
      internal::WebClientHandler_GetImageBytesFromTab_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetImageBytesFromTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.24
      bool success = true;
      int32_t p_tab_id{};
      std::string p_document_id{};
      int32_t p_dom_node_id{};
      WebClientHandler_GetImageBytesFromTab_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadDocumentId(&p_document_id))
        success = false;
      if (success)
        p_dom_node_id = input_data_view.dom_node_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 24, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetImageBytesFromTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetImageBytesFromTab(        
        std::move(p_tab_id), 
        std::move(p_document_id), 
        std::move(p_dom_node_id), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetMaximumNumberOfPinnedTabs: {
      internal::WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.25
      bool success = true;
      uint32_t p_requested_max{};
      WebClientHandler_SetMaximumNumberOfPinnedTabs_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_requested_max = input_data_view.requested_max();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 25, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetMaximumNumberOfPinnedTabs_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetMaximumNumberOfPinnedTabs(        
        std::move(p_requested_max), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kPinTabs: {
      internal::WebClientHandler_PinTabs_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_PinTabs_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.26
      bool success = true;
      std::vector<int32_t> p_tab_ids{};
      PinTabsOptionsPtr p_options{};
      WebClientHandler_PinTabs_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTabIds(&p_tab_ids))
        success = false;
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 26, false);
        return false;
      }
      auto callback =
          WebClientHandler_PinTabs_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PinTabs(        
        std::move(p_tab_ids), 
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kUnpinTabs: {
      internal::WebClientHandler_UnpinTabs_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_UnpinTabs_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.27
      bool success = true;
      std::vector<int32_t> p_tab_ids{};
      UnpinTabsOptionsPtr p_options{};
      WebClientHandler_UnpinTabs_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTabIds(&p_tab_ids))
        success = false;
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 27, false);
        return false;
      }
      auto callback =
          WebClientHandler_UnpinTabs_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UnpinTabs(        
        std::move(p_tab_ids), 
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kUnpinAllTabs: {
      break;
    }
    case messages::WebClientHandler::kSubscribeToPinCandidates: {
      break;
    }
    case messages::WebClientHandler::kOpenPinnedTabPicker: {
      internal::WebClientHandler_OpenPinnedTabPicker_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_OpenPinnedTabPicker_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.30
      bool success = true;
      OpenPinnedTabPickerOptionsPtr p_options{};
      WebClientHandler_OpenPinnedTabPicker_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 30, false);
        return false;
      }
      auto callback =
          WebClientHandler_OpenPinnedTabPicker_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenPinnedTabPicker(        
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kActivateTab: {
      break;
    }
    case messages::WebClientHandler::kResizeWidget: {
      internal::WebClientHandler_ResizeWidget_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_ResizeWidget_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.32
      bool success = true;
      ::gfx::Size p_size{};
      ::base::TimeDelta p_duration{};
      WebClientHandler_ResizeWidget_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSize(&p_size))
        success = false;
      if (success && !input_data_view.ReadDuration(&p_duration))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 32, false);
        return false;
      }
      auto callback =
          WebClientHandler_ResizeWidget_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ResizeWidget(        
        std::move(p_size), 
        std::move(p_duration), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kCaptureScreenshot: {
      internal::WebClientHandler_CaptureScreenshot_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_CaptureScreenshot_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.33
      bool success = true;
      WebClientHandler_CaptureScreenshot_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 33, false);
        return false;
      }
      auto callback =
          WebClientHandler_CaptureScreenshot_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CaptureScreenshot(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kCaptureRegion: {
      break;
    }
    case messages::WebClientHandler::kDeleteCapturedRegion: {
      break;
    }
    case messages::WebClientHandler::kSetAudioDucking: {
      internal::WebClientHandler_SetAudioDucking_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetAudioDucking_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.36
      bool success = true;
      bool p_enable{};
      WebClientHandler_SetAudioDucking_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enable = input_data_view.enable();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 36, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetAudioDucking_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetAudioDucking(        
        std::move(p_enable), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetMinimumPanelSize: {
      break;
    }
    case messages::WebClientHandler::kSetMicrophonePermissionState: {
      internal::WebClientHandler_SetMicrophonePermissionState_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetMicrophonePermissionState_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.38
      bool success = true;
      bool p_enabled{};
      WebClientHandler_SetMicrophonePermissionState_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 38, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetMicrophonePermissionState_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetMicrophonePermissionState(        
        std::move(p_enabled), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetLocationPermissionState: {
      internal::WebClientHandler_SetLocationPermissionState_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetLocationPermissionState_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.39
      bool success = true;
      bool p_enabled{};
      WebClientHandler_SetLocationPermissionState_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 39, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetLocationPermissionState_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetLocationPermissionState(        
        std::move(p_enabled), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetTabContextPermissionState: {
      internal::WebClientHandler_SetTabContextPermissionState_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetTabContextPermissionState_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.40
      bool success = true;
      bool p_enabled{};
      WebClientHandler_SetTabContextPermissionState_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 40, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetTabContextPermissionState_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetTabContextPermissionState(        
        std::move(p_enabled), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetClosedCaptioningSetting: {
      internal::WebClientHandler_SetClosedCaptioningSetting_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetClosedCaptioningSetting_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.41
      bool success = true;
      bool p_enabled{};
      WebClientHandler_SetClosedCaptioningSetting_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 41, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetClosedCaptioningSetting_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetClosedCaptioningSetting(        
        std::move(p_enabled), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetActuationOnWebSetting: {
      internal::WebClientHandler_SetActuationOnWebSetting_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SetActuationOnWebSetting_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.42
      bool success = true;
      bool p_enabled{};
      WebClientHandler_SetActuationOnWebSetting_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 42, false);
        return false;
      }
      auto callback =
          WebClientHandler_SetActuationOnWebSetting_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetActuationOnWebSetting(        
        std::move(p_enabled), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kShouldAllowMediaPermissionRequest: {
      internal::WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.43
      bool success = true;
      WebClientHandler_ShouldAllowMediaPermissionRequest_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 43, false);
        return false;
      }
      auto callback =
          WebClientHandler_ShouldAllowMediaPermissionRequest_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShouldAllowMediaPermissionRequest(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kShouldAllowGeolocationPermissionRequest: {
      internal::WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.44
      bool success = true;
      WebClientHandler_ShouldAllowGeolocationPermissionRequest_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 44, false);
        return false;
      }
      auto callback =
          WebClientHandler_ShouldAllowGeolocationPermissionRequest_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShouldAllowGeolocationPermissionRequest(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetContextAccessIndicator: {
      break;
    }
    case messages::WebClientHandler::kGetUserProfileInfo: {
      internal::WebClientHandler_GetUserProfileInfo_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetUserProfileInfo_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.46
      bool success = true;
      WebClientHandler_GetUserProfileInfo_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 46, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetUserProfileInfo_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetUserProfileInfo(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSyncCookies: {
      internal::WebClientHandler_SyncCookies_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SyncCookies_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.47
      bool success = true;
      WebClientHandler_SyncCookies_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 47, false);
        return false;
      }
      auto callback =
          WebClientHandler_SyncCookies_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SyncCookies(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kClientErrorDialogStateChanged: {
      break;
    }
    case messages::WebClientHandler::kReportClientTransientError: {
      break;
    }
    case messages::WebClientHandler::kProcessCounterAbuseVerdict: {
      break;
    }
    case messages::WebClientHandler::kOnOptinImpression: {
      break;
    }
    case messages::WebClientHandler::kOnUserInputSubmitted: {
      break;
    }
    case messages::WebClientHandler::kOnContextUploadStarted: {
      break;
    }
    case messages::WebClientHandler::kOnContextUploadCompleted: {
      break;
    }
    case messages::WebClientHandler::kOnReaction: {
      break;
    }
    case messages::WebClientHandler::kOnResponseStarted: {
      break;
    }
    case messages::WebClientHandler::kOnResponseStopped: {
      break;
    }
    case messages::WebClientHandler::kOnSessionTerminated: {
      break;
    }
    case messages::WebClientHandler::kOnTurnCompleted: {
      break;
    }
    case messages::WebClientHandler::kOnResponseRated: {
      break;
    }
    case messages::WebClientHandler::kOnClosedCaptionsShown: {
      break;
    }
    case messages::WebClientHandler::kOnActionSubmitted: {
      break;
    }
    case messages::WebClientHandler::kSetSyntheticExperimentState: {
      break;
    }
    case messages::WebClientHandler::kOpenOsPermissionSettingsMenu: {
      break;
    }
    case messages::WebClientHandler::kGetOsMicrophonePermissionStatus: {
      internal::WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.65
      bool success = true;
      WebClientHandler_GetOsMicrophonePermissionStatus_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 65, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetOsMicrophonePermissionStatus_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetOsMicrophonePermissionStatus(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kGetZeroStateSuggestionsForFocusedTab: {
      internal::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.66
      bool success = true;
      std::optional<bool> p_is_first_run{};
      WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_is_first_run = input_data_view.is_first_run();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 66, false);
        return false;
      }
      auto callback =
          WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetZeroStateSuggestionsForFocusedTab(        
        std::move(p_is_first_run), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kMaybeRefreshUserStatus: {
      break;
    }
    case messages::WebClientHandler::kIsDebuggerAttached: {
      internal::WebClientHandler_IsDebuggerAttached_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_IsDebuggerAttached_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.68
      bool success = true;
      WebClientHandler_IsDebuggerAttached_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 68, false);
        return false;
      }
      auto callback =
          WebClientHandler_IsDebuggerAttached_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->IsDebuggerAttached(std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSubscribeToPageMetadata: {
      internal::WebClientHandler_SubscribeToPageMetadata_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SubscribeToPageMetadata_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.69
      bool success = true;
      int32_t p_tab_id{};
      std::vector<std::string> p_names{};
      WebClientHandler_SubscribeToPageMetadata_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadNames(&p_names))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 69, false);
        return false;
      }
      auto callback =
          WebClientHandler_SubscribeToPageMetadata_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SubscribeToPageMetadata(        
        std::move(p_tab_id), 
        std::move(p_names), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSwitchConversation: {
      internal::WebClientHandler_SwitchConversation_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_SwitchConversation_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.70
      bool success = true;
      ConversationInfoPtr p_info{};
      WebClientHandler_SwitchConversation_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadInfo(&p_info))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 70, false);
        return false;
      }
      auto callback =
          WebClientHandler_SwitchConversation_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SwitchConversation(        
        std::move(p_info), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kRegisterConversation: {
      internal::WebClientHandler_RegisterConversation_Params_Data* params =
          reinterpret_cast<
              internal::WebClientHandler_RegisterConversation_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClientHandler.71
      bool success = true;
      ConversationInfoPtr p_info{};
      WebClientHandler_RegisterConversation_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadInfo(&p_info))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClientHandler::Name_, 71, false);
        return false;
      }
      auto callback =
          WebClientHandler_RegisterConversation_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RegisterConversation(        
        std::move(p_info), std::move(callback));
      return true;
    }
    case messages::WebClientHandler::kSetOnboardingCompleted: {
      break;
    }
    case messages::WebClientHandler::kSubscribeToTabData: {
      break;
    }
    case messages::WebClientHandler::kSubscribeToTabFavicon: {
      break;
    }
  }
  return false;
}
namespace {

bool ValidateWithRuntimeFeature_WebClientHandler_GetModelQualityClientId(
  const void* data, mojo::internal::ValidationContext* validation_context) {
  if (!base::FeatureList::IsEnabled(::glic::mojom::features::kGlicAppendModelQualityClientId)) {
    return false;
  }
  return internal::WebClientHandler_GetModelQualityClientId_Params_Data::Validate(
    data, validation_context);
}

bool ValidateWithRuntimeFeature_WebClientHandler_ActivateTab(
  const void* data, mojo::internal::ValidationContext* validation_context) {
  if (!base::FeatureList::IsEnabled(::glic::mojom::features::kGlicActivateTabApi)) {
    return false;
  }
  return internal::WebClientHandler_ActivateTab_Params_Data::Validate(
    data, validation_context);
}
}  // namespace
static const mojo::internal::GenericValidationInfo kWebClientHandlerValidationInfo[] = {
    { &internal::WebClientHandler_WebClientCreated_Params_Data::Validate,
     &internal::WebClientHandler_WebClientCreated_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_WebClientInitialized_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_WebClientInitializeFailed_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_CreateActorHandler_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_CreateExperimentalTriggeringClient_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_CreateAnnotationHandler_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_CreateSkillsHandler_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_CreateTab_Params_Data::Validate,
     &internal::WebClientHandler_CreateTab_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_ActivateTabWithUrl_Params_Data::Validate,
     &internal::WebClientHandler_ActivateTabWithUrl_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_OpenLinkInPopup_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OpenGlicSettingsPage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_EnableDragResize_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_ClosePanel_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_ClosePanelAndShutdown_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_AttachPanel_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_DetachPanel_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnModeChange_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnMicrophoneStatusChange_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_ShowProfilePicker_Params_Data::Validate,
     nullptr /* no response */},
    { &ValidateWithRuntimeFeature_WebClientHandler_GetModelQualityClientId,
     &internal::WebClientHandler_GetModelQualityClientId_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_GetContextFromFocusedTab_Params_Data::Validate,
     &internal::WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_GetContextFromTab_Params_Data::Validate,
     &internal::WebClientHandler_GetContextFromTab_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_GetImageBytesFromTab_Params_Data::Validate,
     &internal::WebClientHandler_GetImageBytesFromTab_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data::Validate,
     &internal::WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_PinTabs_Params_Data::Validate,
     &internal::WebClientHandler_PinTabs_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_UnpinTabs_Params_Data::Validate,
     &internal::WebClientHandler_UnpinTabs_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_UnpinAllTabs_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_SubscribeToPinCandidates_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OpenPinnedTabPicker_Params_Data::Validate,
     &internal::WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data::Validate},
    { &ValidateWithRuntimeFeature_WebClientHandler_ActivateTab,
     nullptr /* no response */},
    { &internal::WebClientHandler_ResizeWidget_Params_Data::Validate,
     &internal::WebClientHandler_ResizeWidget_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_CaptureScreenshot_Params_Data::Validate,
     &internal::WebClientHandler_CaptureScreenshot_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_CaptureRegion_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_DeleteCapturedRegion_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_SetAudioDucking_Params_Data::Validate,
     &internal::WebClientHandler_SetAudioDucking_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetMinimumPanelSize_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_SetMicrophonePermissionState_Params_Data::Validate,
     &internal::WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetLocationPermissionState_Params_Data::Validate,
     &internal::WebClientHandler_SetLocationPermissionState_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetTabContextPermissionState_Params_Data::Validate,
     &internal::WebClientHandler_SetTabContextPermissionState_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetClosedCaptioningSetting_Params_Data::Validate,
     &internal::WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetActuationOnWebSetting_Params_Data::Validate,
     &internal::WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data::Validate,
     &internal::WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data::Validate,
     &internal::WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetContextAccessIndicator_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_GetUserProfileInfo_Params_Data::Validate,
     &internal::WebClientHandler_GetUserProfileInfo_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SyncCookies_Params_Data::Validate,
     &internal::WebClientHandler_SyncCookies_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_ClientErrorDialogStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_ReportClientTransientError_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_ProcessCounterAbuseVerdict_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnOptinImpression_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnUserInputSubmitted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnContextUploadStarted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnContextUploadCompleted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnReaction_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnResponseStarted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnResponseStopped_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnSessionTerminated_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnTurnCompleted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnResponseRated_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnClosedCaptionsShown_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OnActionSubmitted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_SetSyntheticExperimentState_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data::Validate,
     &internal::WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data::Validate,
     &internal::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_MaybeRefreshUserStatus_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_IsDebuggerAttached_Params_Data::Validate,
     &internal::WebClientHandler_IsDebuggerAttached_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SubscribeToPageMetadata_Params_Data::Validate,
     &internal::WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SwitchConversation_Params_Data::Validate,
     &internal::WebClientHandler_SwitchConversation_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_RegisterConversation_Params_Data::Validate,
     &internal::WebClientHandler_RegisterConversation_ResponseParams_Data::Validate},
    { &internal::WebClientHandler_SetOnboardingCompleted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_SubscribeToTabData_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClientHandler_SubscribeToTabFavicon_Params_Data::Validate,
     nullptr /* no response */},
};

bool WebClientHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::WebClientHandler::Name_,
    kWebClientHandlerValidationInfo);
}

bool WebClientHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::WebClientHandler::Name_,
    kWebClientHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

ZeroStateSuggestionsHandler::IPCStableHashFunction ZeroStateSuggestionsHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ZeroStateSuggestionsHandler>(message.name())) {
    case messages::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe: {
      return &ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ZeroStateSuggestionsHandler::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::ZeroStateSuggestionsHandler>(message.name())) {
      case messages::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe:
            return "Receive glic::mojom::ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe";
    }
  } else {
    switch (static_cast<messages::ZeroStateSuggestionsHandler>(message.name())) {
      case messages::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe:
            return "Receive reply glic::mojom::ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe";
    }
  }
  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 ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe_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 = 0x4148aa54;  // IPCStableHash for glic::mojom::ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ForwardToCallback(
      ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribeCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribeCallback callback_;
};

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

void ZeroStateSuggestionsHandlerProxy::GetZeroStateSuggestionsAndSubscribe(
    ::mojo::PendingRemote<ZeroStateSuggestionsClient> in_client, ZeroStateSuggestionsOptionsPtr in_options, GetZeroStateSuggestionsAndSubscribeCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("client"), in_client,
                        "<value of type ::mojo::PendingRemote<ZeroStateSuggestionsClient>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type ZeroStateSuggestionsOptionsPtr>");
   });
#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::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::ZeroStateSuggestionsClientInterfaceBase>>(
    in_client,
    &params->client,
    &params.message());
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ZeroStateSuggestionsOptionsDataView>(
    in_options,
    options_fragment);

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

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

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

  ~ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_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:
  ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_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)
        << "ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribeCallback 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(
      ZeroStateSuggestionsV2Ptr in_zero_state_suggestions);
};

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

  // Validation for ZeroStateSuggestionsHandler.0
  bool success = true;
  ZeroStateSuggestionsV2Ptr p_zero_state_suggestions{};
  ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadZeroStateSuggestions(&p_zero_state_suggestions))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ZeroStateSuggestionsHandler::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_zero_state_suggestions));
  }
  return true;
}

void ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ProxyToResponder::Run(
    ZeroStateSuggestionsV2Ptr in_zero_state_suggestions) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ZeroStateSuggestionsHandler::GetZeroStateSuggestionsAndSubscribe", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("zero_state_suggestions"), in_zero_state_suggestions,
                        "<value of type ZeroStateSuggestionsV2Ptr>");
   });
#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::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->zero_state_suggestions)::BaseType> zero_state_suggestions_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ZeroStateSuggestionsV2DataView>(
    in_zero_state_suggestions,
    zero_state_suggestions_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ZeroStateSuggestionsHandler::Name_);
  message.set_method_name("GetZeroStateSuggestionsAndSubscribe");
#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 ZeroStateSuggestionsHandlerStubDispatch::Accept(
    ZeroStateSuggestionsHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ZeroStateSuggestionsHandler>(message->header()->name)) {
    case messages::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe: {
      break;
    }
  }
  return false;
}

// static
bool ZeroStateSuggestionsHandlerStubDispatch::AcceptWithResponder(
    ZeroStateSuggestionsHandler* 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::ZeroStateSuggestionsHandler>(message->header()->name)) {
    case messages::ZeroStateSuggestionsHandler::kGetZeroStateSuggestionsAndSubscribe: {
      internal::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data* params =
          reinterpret_cast<
              internal::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ZeroStateSuggestionsHandler.0
      bool success = true;
      ::mojo::PendingRemote<ZeroStateSuggestionsClient> p_client{};
      ZeroStateSuggestionsOptionsPtr p_options{};
      ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_client =
            input_data_view.TakeClient<decltype(p_client)>();
      }
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ZeroStateSuggestionsHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetZeroStateSuggestionsAndSubscribe(        
        std::move(p_client), 
        std::move(p_options), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kZeroStateSuggestionsHandlerValidationInfo[] = {
    { &internal::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data::Validate,
     &internal::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data::Validate},
};

bool ZeroStateSuggestionsHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::ZeroStateSuggestionsHandler::Name_,
    kZeroStateSuggestionsHandlerValidationInfo);
}

bool ZeroStateSuggestionsHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::ZeroStateSuggestionsHandler::Name_,
    kZeroStateSuggestionsHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

ZeroStateSuggestionsClient::IPCStableHashFunction ZeroStateSuggestionsClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ZeroStateSuggestionsClient>(message.name())) {
    case messages::ZeroStateSuggestionsClient::kNotifyZeroStateSuggestionsChanged: {
      return &ZeroStateSuggestionsClient::NotifyZeroStateSuggestionsChanged_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ZeroStateSuggestionsClient::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::ZeroStateSuggestionsClient>(message.name())) {
      case messages::ZeroStateSuggestionsClient::kNotifyZeroStateSuggestionsChanged:
            return "Receive glic::mojom::ZeroStateSuggestionsClient::NotifyZeroStateSuggestionsChanged";
    }
  } else {
    switch (static_cast<messages::ZeroStateSuggestionsClient>(message.name())) {
      case messages::ZeroStateSuggestionsClient::kNotifyZeroStateSuggestionsChanged:
            return "Receive reply glic::mojom::ZeroStateSuggestionsClient::NotifyZeroStateSuggestionsChanged";
    }
  }
  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 ZeroStateSuggestionsClient::NotifyZeroStateSuggestionsChanged_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 = 0x38b8802b;  // IPCStableHash for glic::mojom::ZeroStateSuggestionsClient::NotifyZeroStateSuggestionsChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void ZeroStateSuggestionsClientProxy::NotifyZeroStateSuggestionsChanged(
    ZeroStateSuggestionsV2Ptr in_suggestions, ZeroStateSuggestionsOptionsPtr in_options) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ZeroStateSuggestionsClient::NotifyZeroStateSuggestionsChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("suggestions"), in_suggestions,
                        "<value of type ZeroStateSuggestionsV2Ptr>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type ZeroStateSuggestionsOptionsPtr>");
   });
#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::ZeroStateSuggestionsClient::kNotifyZeroStateSuggestionsChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->suggestions)::BaseType> suggestions_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ZeroStateSuggestionsV2DataView>(
    in_suggestions,
    suggestions_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->suggestions.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null suggestions in ZeroStateSuggestionsClient.NotifyZeroStateSuggestionsChanged request");
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ZeroStateSuggestionsOptionsDataView>(
    in_options,
    options_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ZeroStateSuggestionsClient::Name_);
  message.set_method_name("NotifyZeroStateSuggestionsChanged");
#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 ZeroStateSuggestionsClientStubDispatch::Accept(
    ZeroStateSuggestionsClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ZeroStateSuggestionsClient>(message->header()->name)) {
    case messages::ZeroStateSuggestionsClient::kNotifyZeroStateSuggestionsChanged: {
      DCHECK(message->is_serialized());
      internal::ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data* params =
          reinterpret_cast<internal::ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ZeroStateSuggestionsClient.0
      bool success = true;
      ZeroStateSuggestionsV2Ptr p_suggestions{};
      ZeroStateSuggestionsOptionsPtr p_options{};
      ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSuggestions(&p_suggestions))
        success = false;
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ZeroStateSuggestionsClient::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyZeroStateSuggestionsChanged(        
        std::move(p_suggestions), 
        std::move(p_options));
      return true;
    }
  }
  return false;
}

// static
bool ZeroStateSuggestionsClientStubDispatch::AcceptWithResponder(
    ZeroStateSuggestionsClient* 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::ZeroStateSuggestionsClient>(message->header()->name)) {
    case messages::ZeroStateSuggestionsClient::kNotifyZeroStateSuggestionsChanged: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kZeroStateSuggestionsClientValidationInfo[] = {
    { &internal::ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data::Validate,
     nullptr /* no response */},
};

bool ZeroStateSuggestionsClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::ZeroStateSuggestionsClient::Name_,
    kZeroStateSuggestionsClientValidationInfo);
}

// The declaration includes the definition on other builds.

TabDataHandler::IPCStableHashFunction TabDataHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::TabDataHandler>(message.name())) {
    case messages::TabDataHandler::kOnTabDataChanged: {
      return &TabDataHandler::OnTabDataChanged_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* TabDataHandler::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::TabDataHandler>(message.name())) {
      case messages::TabDataHandler::kOnTabDataChanged:
            return "Receive glic::mojom::TabDataHandler::OnTabDataChanged";
    }
  } else {
    switch (static_cast<messages::TabDataHandler>(message.name())) {
      case messages::TabDataHandler::kOnTabDataChanged:
            return "Receive reply glic::mojom::TabDataHandler::OnTabDataChanged";
    }
  }
  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 TabDataHandler::OnTabDataChanged_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 = 0x1cae27b7;  // IPCStableHash for glic::mojom::TabDataHandler::OnTabDataChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void TabDataHandlerProxy::OnTabDataChanged(
    TabDataPtr in_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::TabDataHandler::OnTabDataChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_data"), in_tab_data,
                        "<value of type TabDataPtr>");
   });
#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::TabDataHandler::kOnTabDataChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::TabDataHandler_OnTabDataChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_data)::BaseType> tab_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabDataDataView>(
    in_tab_data,
    tab_data_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TabDataHandler::Name_);
  message.set_method_name("OnTabDataChanged");
#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 TabDataHandlerStubDispatch::Accept(
    TabDataHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::TabDataHandler>(message->header()->name)) {
    case messages::TabDataHandler::kOnTabDataChanged: {
      DCHECK(message->is_serialized());
      internal::TabDataHandler_OnTabDataChanged_Params_Data* params =
          reinterpret_cast<internal::TabDataHandler_OnTabDataChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for TabDataHandler.0
      bool success = true;
      TabDataPtr p_tab_data{};
      TabDataHandler_OnTabDataChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTabData(&p_tab_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TabDataHandler::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTabDataChanged(        
        std::move(p_tab_data));
      return true;
    }
  }
  return false;
}

// static
bool TabDataHandlerStubDispatch::AcceptWithResponder(
    TabDataHandler* 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::TabDataHandler>(message->header()->name)) {
    case messages::TabDataHandler::kOnTabDataChanged: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kTabDataHandlerValidationInfo[] = {
    { &internal::TabDataHandler_OnTabDataChanged_Params_Data::Validate,
     nullptr /* no response */},
};

bool TabDataHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::TabDataHandler::Name_,
    kTabDataHandlerValidationInfo);
}

// The declaration includes the definition on other builds.

TabFaviconHandler::IPCStableHashFunction TabFaviconHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::TabFaviconHandler>(message.name())) {
    case messages::TabFaviconHandler::kOnTabFaviconChanged: {
      return &TabFaviconHandler::OnTabFaviconChanged_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* TabFaviconHandler::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::TabFaviconHandler>(message.name())) {
      case messages::TabFaviconHandler::kOnTabFaviconChanged:
            return "Receive glic::mojom::TabFaviconHandler::OnTabFaviconChanged";
    }
  } else {
    switch (static_cast<messages::TabFaviconHandler>(message.name())) {
      case messages::TabFaviconHandler::kOnTabFaviconChanged:
            return "Receive reply glic::mojom::TabFaviconHandler::OnTabFaviconChanged";
    }
  }
  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 TabFaviconHandler::OnTabFaviconChanged_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 = 0x12464f7d;  // IPCStableHash for glic::mojom::TabFaviconHandler::OnTabFaviconChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void TabFaviconHandlerProxy::OnTabFaviconChanged(
    const ::SkBitmap& in_favicon) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::TabFaviconHandler::OnTabFaviconChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("favicon"), in_favicon,
                        "<value of type const ::SkBitmap&>");
   });
#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::TabFaviconHandler::kOnTabFaviconChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::TabFaviconHandler_OnTabFaviconChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->favicon)::BaseType> favicon_fragment(
          params.message());
  
  mojo::internal::Serialize<::skia::mojom::BitmapN32DataView>(
    in_favicon,
    favicon_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(TabFaviconHandler::Name_);
  message.set_method_name("OnTabFaviconChanged");
#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 TabFaviconHandlerStubDispatch::Accept(
    TabFaviconHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::TabFaviconHandler>(message->header()->name)) {
    case messages::TabFaviconHandler::kOnTabFaviconChanged: {
      DCHECK(message->is_serialized());
      internal::TabFaviconHandler_OnTabFaviconChanged_Params_Data* params =
          reinterpret_cast<internal::TabFaviconHandler_OnTabFaviconChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for TabFaviconHandler.0
      bool success = true;
      ::SkBitmap p_favicon{};
      TabFaviconHandler_OnTabFaviconChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadFavicon(&p_favicon))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            TabFaviconHandler::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTabFaviconChanged(        
        std::move(p_favicon));
      return true;
    }
  }
  return false;
}

// static
bool TabFaviconHandlerStubDispatch::AcceptWithResponder(
    TabFaviconHandler* 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::TabFaviconHandler>(message->header()->name)) {
    case messages::TabFaviconHandler::kOnTabFaviconChanged: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kTabFaviconHandlerValidationInfo[] = {
    { &internal::TabFaviconHandler_OnTabFaviconChanged_Params_Data::Validate,
     nullptr /* no response */},
};

bool TabFaviconHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::TabFaviconHandler::Name_,
    kTabFaviconHandlerValidationInfo);
}

// The declaration includes the definition on other builds.

ExperimentalTriggeringUpdatesHandler::IPCStableHashFunction ExperimentalTriggeringUpdatesHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ExperimentalTriggeringUpdatesHandler>(message.name())) {
    case messages::ExperimentalTriggeringUpdatesHandler::kOnUpdate: {
      return &ExperimentalTriggeringUpdatesHandler::OnUpdate_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ExperimentalTriggeringUpdatesHandler::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::ExperimentalTriggeringUpdatesHandler>(message.name())) {
      case messages::ExperimentalTriggeringUpdatesHandler::kOnUpdate:
            return "Receive glic::mojom::ExperimentalTriggeringUpdatesHandler::OnUpdate";
    }
  } else {
    switch (static_cast<messages::ExperimentalTriggeringUpdatesHandler>(message.name())) {
      case messages::ExperimentalTriggeringUpdatesHandler::kOnUpdate:
            return "Receive reply glic::mojom::ExperimentalTriggeringUpdatesHandler::OnUpdate";
    }
  }
  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 ExperimentalTriggeringUpdatesHandler::OnUpdate_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 = 0x6eef534a;  // IPCStableHash for glic::mojom::ExperimentalTriggeringUpdatesHandler::OnUpdate
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void ExperimentalTriggeringUpdatesHandlerProxy::OnUpdate(
    ExperimentalTriggeringUpdatePtr in_update, SubscriberObservationType in_observation) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ExperimentalTriggeringUpdatesHandler::OnUpdate", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("update"), in_update,
                        "<value of type ExperimentalTriggeringUpdatePtr>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("observation"), in_observation,
                        "<value of type SubscriberObservationType>");
   });
#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::ExperimentalTriggeringUpdatesHandler::kOnUpdate), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->update)::BaseType> update_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ExperimentalTriggeringUpdateDataView>(
    in_update,
    update_fragment);

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

  
  mojo::internal::Serialize<::glic::mojom::SubscriberObservationType>(
    in_observation,
    &params->observation);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExperimentalTriggeringUpdatesHandler::Name_);
  message.set_method_name("OnUpdate");
#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 ExperimentalTriggeringUpdatesHandlerStubDispatch::Accept(
    ExperimentalTriggeringUpdatesHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ExperimentalTriggeringUpdatesHandler>(message->header()->name)) {
    case messages::ExperimentalTriggeringUpdatesHandler::kOnUpdate: {
      DCHECK(message->is_serialized());
      internal::ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data* params =
          reinterpret_cast<internal::ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ExperimentalTriggeringUpdatesHandler.0
      bool success = true;
      ExperimentalTriggeringUpdatePtr p_update{};
      SubscriberObservationType p_observation{};
      ExperimentalTriggeringUpdatesHandler_OnUpdate_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUpdate(&p_update))
        success = false;
      if (success && !input_data_view.ReadObservation(&p_observation))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExperimentalTriggeringUpdatesHandler::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnUpdate(        
        std::move(p_update), 
        std::move(p_observation));
      return true;
    }
  }
  return false;
}

// static
bool ExperimentalTriggeringUpdatesHandlerStubDispatch::AcceptWithResponder(
    ExperimentalTriggeringUpdatesHandler* 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::ExperimentalTriggeringUpdatesHandler>(message->header()->name)) {
    case messages::ExperimentalTriggeringUpdatesHandler::kOnUpdate: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kExperimentalTriggeringUpdatesHandlerValidationInfo[] = {
    { &internal::ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data::Validate,
     nullptr /* no response */},
};

bool ExperimentalTriggeringUpdatesHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::ExperimentalTriggeringUpdatesHandler::Name_,
    kExperimentalTriggeringUpdatesHandlerValidationInfo);
}

// The declaration includes the definition on other builds.

ExperimentalTriggeringClient::IPCStableHashFunction ExperimentalTriggeringClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ExperimentalTriggeringClient>(message.name())) {
    case messages::ExperimentalTriggeringClient::kUploadEncryptedScreenshot: {
      return &ExperimentalTriggeringClient::UploadEncryptedScreenshot_Sym::IPCStableHash;
    }
    case messages::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates: {
      return &ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ExperimentalTriggeringClient::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::ExperimentalTriggeringClient>(message.name())) {
      case messages::ExperimentalTriggeringClient::kUploadEncryptedScreenshot:
            return "Receive glic::mojom::ExperimentalTriggeringClient::UploadEncryptedScreenshot";
      case messages::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates:
            return "Receive glic::mojom::ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates";
    }
  } else {
    switch (static_cast<messages::ExperimentalTriggeringClient>(message.name())) {
      case messages::ExperimentalTriggeringClient::kUploadEncryptedScreenshot:
            return "Receive reply glic::mojom::ExperimentalTriggeringClient::UploadEncryptedScreenshot";
      case messages::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates:
            return "Receive reply glic::mojom::ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates";
    }
  }
  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 ExperimentalTriggeringClient::UploadEncryptedScreenshot_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 = 0xe9668385;  // IPCStableHash for glic::mojom::ExperimentalTriggeringClient::UploadEncryptedScreenshot
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates_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 = 0x350500f5;  // IPCStableHash for glic::mojom::ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ExperimentalTriggeringClient_UploadEncryptedScreenshot_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ExperimentalTriggeringClient_UploadEncryptedScreenshot_ForwardToCallback(
      ExperimentalTriggeringClient::UploadEncryptedScreenshotCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ExperimentalTriggeringClient::UploadEncryptedScreenshotCallback callback_;
};

class ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ForwardToCallback(
      ExperimentalTriggeringClient::GetExperimentalTriggeringUpdatesCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ExperimentalTriggeringClient::GetExperimentalTriggeringUpdatesCallback callback_;
};

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

void ExperimentalTriggeringClientProxy::UploadEncryptedScreenshot(
    ScreenshotPtr in_screenshot, UploadEncryptedScreenshotCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ExperimentalTriggeringClient::UploadEncryptedScreenshot", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("screenshot"), in_screenshot,
                        "<value of type ScreenshotPtr>");
   });
#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::ExperimentalTriggeringClient::kUploadEncryptedScreenshot), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->screenshot)::BaseType> screenshot_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::ScreenshotDataView>(
    in_screenshot,
    screenshot_fragment);

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

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

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

void ExperimentalTriggeringClientProxy::GetExperimentalTriggeringUpdates(
    ::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> in_handler, GetExperimentalTriggeringUpdatesCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("handler"), in_handler,
                        "<value of type ::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler>>");
   });
#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::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::glic::mojom::ExperimentalTriggeringUpdatesHandlerInterfaceBase>>(
    in_handler,
    &params->handler,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->handler)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid handler in ExperimentalTriggeringClient.GetExperimentalTriggeringUpdates request");

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

  ~ExperimentalTriggeringClient_UploadEncryptedScreenshot_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:
  ExperimentalTriggeringClient_UploadEncryptedScreenshot_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)
        << "ExperimentalTriggeringClient::UploadEncryptedScreenshotCallback 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 std::optional<std::string>& in_file_token);
};

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

  // Validation for ExperimentalTriggeringClient.0
  bool success = true;
  std::optional<std::string> p_file_token{};
  ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadFileToken(&p_file_token))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ExperimentalTriggeringClient::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_file_token));
  }
  return true;
}

void ExperimentalTriggeringClient_UploadEncryptedScreenshot_ProxyToResponder::Run(
    const std::optional<std::string>& in_file_token) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ExperimentalTriggeringClient::UploadEncryptedScreenshot", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("file_token"), in_file_token,
                        "<value of type const std::optional<std::string>&>");
   });
#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::ExperimentalTriggeringClient::kUploadEncryptedScreenshot), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->file_token)::BaseType> file_token_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_file_token,
    file_token_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExperimentalTriggeringClient::Name_);
  message.set_method_name("UploadEncryptedScreenshot");
#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 ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static ExperimentalTriggeringClient::GetExperimentalTriggeringUpdatesCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ProxyToResponder> proxy(
        new ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_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:
  ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_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)
        << "ExperimentalTriggeringClient::GetExperimentalTriggeringUpdatesCallback 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 in_success);
};

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

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

void ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ProxyToResponder::Run(
    bool in_success) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::ExperimentalTriggeringClient::GetExperimentalTriggeringUpdates", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
   });
#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::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExperimentalTriggeringClient::Name_);
  message.set_method_name("GetExperimentalTriggeringUpdates");
#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 ExperimentalTriggeringClientStubDispatch::Accept(
    ExperimentalTriggeringClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ExperimentalTriggeringClient>(message->header()->name)) {
    case messages::ExperimentalTriggeringClient::kUploadEncryptedScreenshot: {
      break;
    }
    case messages::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates: {
      break;
    }
  }
  return false;
}

// static
bool ExperimentalTriggeringClientStubDispatch::AcceptWithResponder(
    ExperimentalTriggeringClient* 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::ExperimentalTriggeringClient>(message->header()->name)) {
    case messages::ExperimentalTriggeringClient::kUploadEncryptedScreenshot: {
      internal::ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data* params =
          reinterpret_cast<
              internal::ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ExperimentalTriggeringClient.0
      bool success = true;
      ScreenshotPtr p_screenshot{};
      ExperimentalTriggeringClient_UploadEncryptedScreenshot_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadScreenshot(&p_screenshot))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExperimentalTriggeringClient::Name_, 0, false);
        return false;
      }
      auto callback =
          ExperimentalTriggeringClient_UploadEncryptedScreenshot_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UploadEncryptedScreenshot(        
        std::move(p_screenshot), std::move(callback));
      return true;
    }
    case messages::ExperimentalTriggeringClient::kGetExperimentalTriggeringUpdates: {
      internal::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data* params =
          reinterpret_cast<
              internal::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ExperimentalTriggeringClient.1
      bool success = true;
      ::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> p_handler{};
      ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_handler =
            input_data_view.TakeHandler<decltype(p_handler)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExperimentalTriggeringClient::Name_, 1, false);
        return false;
      }
      auto callback =
          ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetExperimentalTriggeringUpdates(        
        std::move(p_handler), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kExperimentalTriggeringClientValidationInfo[] = {
    { &internal::ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data::Validate,
     &internal::ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data::Validate},
    { &internal::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data::Validate,
     &internal::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data::Validate},
};

bool ExperimentalTriggeringClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::ExperimentalTriggeringClient::Name_,
    kExperimentalTriggeringClientValidationInfo);
}

bool ExperimentalTriggeringClientResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::ExperimentalTriggeringClient::Name_,
    kExperimentalTriggeringClientValidationInfo);
}
// The declaration includes the definition on other builds.

WebClient::IPCStableHashFunction WebClient::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::WebClient>(message.name())) {
    case messages::WebClient::kCheckResponsive: {
      return &WebClient::CheckResponsive_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPanelWillOpen: {
      return &WebClient::NotifyPanelWillOpen_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPanelWasClosed: {
      return &WebClient::NotifyPanelWasClosed_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPanelStateChange: {
      return &WebClient::NotifyPanelStateChange_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPanelActiveChange: {
      return &WebClient::NotifyPanelActiveChange_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPanelCanAttachChange: {
      return &WebClient::NotifyPanelCanAttachChange_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyMicrophonePermissionStateChanged: {
      return &WebClient::NotifyMicrophonePermissionStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyFileUploadStateChanged: {
      return &WebClient::NotifyFileUploadStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kStopMicrophone: {
      return &WebClient::StopMicrophone_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyLocationPermissionStateChanged: {
      return &WebClient::NotifyLocationPermissionStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyTabContextPermissionStateChanged: {
      return &WebClient::NotifyTabContextPermissionStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyOsLocationPermissionStateChanged: {
      return &WebClient::NotifyOsLocationPermissionStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyFocusedTabChanged: {
      return &WebClient::NotifyFocusedTabChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyManualResizeChanged: {
      return &WebClient::NotifyManualResizeChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyOsHotkeyStateChanged: {
      return &WebClient::NotifyOsHotkeyStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyBrowserIsOpenChanged: {
      return &WebClient::NotifyBrowserIsOpenChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyZoomLevelChanged: {
      return &WebClient::NotifyZoomLevelChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyInstanceActivationChanged: {
      return &WebClient::NotifyInstanceActivationChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyClosedCaptioningSettingChanged: {
      return &WebClient::NotifyClosedCaptioningSettingChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPinnedTabsChanged: {
      return &WebClient::NotifyPinnedTabsChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPinnedTabDataChanged: {
      return &WebClient::NotifyPinnedTabDataChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyPageMetadataChanged: {
      return &WebClient::NotifyPageMetadataChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyDefaultTabContextPermissionStateChanged: {
      return &WebClient::NotifyDefaultTabContextPermissionStateChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyAdditionalContext: {
      return &WebClient::NotifyAdditionalContext_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyActuationOnWebSettingChanged: {
      return &WebClient::NotifyActuationOnWebSettingChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyActOnWebCapabilityChanged: {
      return &WebClient::NotifyActOnWebCapabilityChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyOnboardingCompletedChanged: {
      return &WebClient::NotifyOnboardingCompletedChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyGeminiEnterpriseSettingsChanged: {
      return &WebClient::NotifyGeminiEnterpriseSettingsChanged_Sym::IPCStableHash;
    }
    case messages::WebClient::kNotifyActorTaskListRowClicked: {
      return &WebClient::NotifyActorTaskListRowClicked_Sym::IPCStableHash;
    }
    case messages::WebClient::kInvoke: {
      return &WebClient::Invoke_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* WebClient::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::WebClient>(message.name())) {
      case messages::WebClient::kCheckResponsive:
            return "Receive glic::mojom::WebClient::CheckResponsive";
      case messages::WebClient::kNotifyPanelWillOpen:
            return "Receive glic::mojom::WebClient::NotifyPanelWillOpen";
      case messages::WebClient::kNotifyPanelWasClosed:
            return "Receive glic::mojom::WebClient::NotifyPanelWasClosed";
      case messages::WebClient::kNotifyPanelStateChange:
            return "Receive glic::mojom::WebClient::NotifyPanelStateChange";
      case messages::WebClient::kNotifyPanelActiveChange:
            return "Receive glic::mojom::WebClient::NotifyPanelActiveChange";
      case messages::WebClient::kNotifyPanelCanAttachChange:
            return "Receive glic::mojom::WebClient::NotifyPanelCanAttachChange";
      case messages::WebClient::kNotifyMicrophonePermissionStateChanged:
            return "Receive glic::mojom::WebClient::NotifyMicrophonePermissionStateChanged";
      case messages::WebClient::kNotifyFileUploadStateChanged:
            return "Receive glic::mojom::WebClient::NotifyFileUploadStateChanged";
      case messages::WebClient::kStopMicrophone:
            return "Receive glic::mojom::WebClient::StopMicrophone";
      case messages::WebClient::kNotifyLocationPermissionStateChanged:
            return "Receive glic::mojom::WebClient::NotifyLocationPermissionStateChanged";
      case messages::WebClient::kNotifyTabContextPermissionStateChanged:
            return "Receive glic::mojom::WebClient::NotifyTabContextPermissionStateChanged";
      case messages::WebClient::kNotifyOsLocationPermissionStateChanged:
            return "Receive glic::mojom::WebClient::NotifyOsLocationPermissionStateChanged";
      case messages::WebClient::kNotifyFocusedTabChanged:
            return "Receive glic::mojom::WebClient::NotifyFocusedTabChanged";
      case messages::WebClient::kNotifyManualResizeChanged:
            return "Receive glic::mojom::WebClient::NotifyManualResizeChanged";
      case messages::WebClient::kNotifyOsHotkeyStateChanged:
            return "Receive glic::mojom::WebClient::NotifyOsHotkeyStateChanged";
      case messages::WebClient::kNotifyBrowserIsOpenChanged:
            return "Receive glic::mojom::WebClient::NotifyBrowserIsOpenChanged";
      case messages::WebClient::kNotifyZoomLevelChanged:
            return "Receive glic::mojom::WebClient::NotifyZoomLevelChanged";
      case messages::WebClient::kNotifyInstanceActivationChanged:
            return "Receive glic::mojom::WebClient::NotifyInstanceActivationChanged";
      case messages::WebClient::kNotifyClosedCaptioningSettingChanged:
            return "Receive glic::mojom::WebClient::NotifyClosedCaptioningSettingChanged";
      case messages::WebClient::kNotifyPinnedTabsChanged:
            return "Receive glic::mojom::WebClient::NotifyPinnedTabsChanged";
      case messages::WebClient::kNotifyPinnedTabDataChanged:
            return "Receive glic::mojom::WebClient::NotifyPinnedTabDataChanged";
      case messages::WebClient::kNotifyPageMetadataChanged:
            return "Receive glic::mojom::WebClient::NotifyPageMetadataChanged";
      case messages::WebClient::kNotifyDefaultTabContextPermissionStateChanged:
            return "Receive glic::mojom::WebClient::NotifyDefaultTabContextPermissionStateChanged";
      case messages::WebClient::kNotifyAdditionalContext:
            return "Receive glic::mojom::WebClient::NotifyAdditionalContext";
      case messages::WebClient::kNotifyActuationOnWebSettingChanged:
            return "Receive glic::mojom::WebClient::NotifyActuationOnWebSettingChanged";
      case messages::WebClient::kNotifyActOnWebCapabilityChanged:
            return "Receive glic::mojom::WebClient::NotifyActOnWebCapabilityChanged";
      case messages::WebClient::kNotifyOnboardingCompletedChanged:
            return "Receive glic::mojom::WebClient::NotifyOnboardingCompletedChanged";
      case messages::WebClient::kNotifyGeminiEnterpriseSettingsChanged:
            return "Receive glic::mojom::WebClient::NotifyGeminiEnterpriseSettingsChanged";
      case messages::WebClient::kNotifyActorTaskListRowClicked:
            return "Receive glic::mojom::WebClient::NotifyActorTaskListRowClicked";
      case messages::WebClient::kInvoke:
            return "Receive glic::mojom::WebClient::Invoke";
    }
  } else {
    switch (static_cast<messages::WebClient>(message.name())) {
      case messages::WebClient::kCheckResponsive:
            return "Receive reply glic::mojom::WebClient::CheckResponsive";
      case messages::WebClient::kNotifyPanelWillOpen:
            return "Receive reply glic::mojom::WebClient::NotifyPanelWillOpen";
      case messages::WebClient::kNotifyPanelWasClosed:
            return "Receive reply glic::mojom::WebClient::NotifyPanelWasClosed";
      case messages::WebClient::kNotifyPanelStateChange:
            return "Receive reply glic::mojom::WebClient::NotifyPanelStateChange";
      case messages::WebClient::kNotifyPanelActiveChange:
            return "Receive reply glic::mojom::WebClient::NotifyPanelActiveChange";
      case messages::WebClient::kNotifyPanelCanAttachChange:
            return "Receive reply glic::mojom::WebClient::NotifyPanelCanAttachChange";
      case messages::WebClient::kNotifyMicrophonePermissionStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyMicrophonePermissionStateChanged";
      case messages::WebClient::kNotifyFileUploadStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyFileUploadStateChanged";
      case messages::WebClient::kStopMicrophone:
            return "Receive reply glic::mojom::WebClient::StopMicrophone";
      case messages::WebClient::kNotifyLocationPermissionStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyLocationPermissionStateChanged";
      case messages::WebClient::kNotifyTabContextPermissionStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyTabContextPermissionStateChanged";
      case messages::WebClient::kNotifyOsLocationPermissionStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyOsLocationPermissionStateChanged";
      case messages::WebClient::kNotifyFocusedTabChanged:
            return "Receive reply glic::mojom::WebClient::NotifyFocusedTabChanged";
      case messages::WebClient::kNotifyManualResizeChanged:
            return "Receive reply glic::mojom::WebClient::NotifyManualResizeChanged";
      case messages::WebClient::kNotifyOsHotkeyStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyOsHotkeyStateChanged";
      case messages::WebClient::kNotifyBrowserIsOpenChanged:
            return "Receive reply glic::mojom::WebClient::NotifyBrowserIsOpenChanged";
      case messages::WebClient::kNotifyZoomLevelChanged:
            return "Receive reply glic::mojom::WebClient::NotifyZoomLevelChanged";
      case messages::WebClient::kNotifyInstanceActivationChanged:
            return "Receive reply glic::mojom::WebClient::NotifyInstanceActivationChanged";
      case messages::WebClient::kNotifyClosedCaptioningSettingChanged:
            return "Receive reply glic::mojom::WebClient::NotifyClosedCaptioningSettingChanged";
      case messages::WebClient::kNotifyPinnedTabsChanged:
            return "Receive reply glic::mojom::WebClient::NotifyPinnedTabsChanged";
      case messages::WebClient::kNotifyPinnedTabDataChanged:
            return "Receive reply glic::mojom::WebClient::NotifyPinnedTabDataChanged";
      case messages::WebClient::kNotifyPageMetadataChanged:
            return "Receive reply glic::mojom::WebClient::NotifyPageMetadataChanged";
      case messages::WebClient::kNotifyDefaultTabContextPermissionStateChanged:
            return "Receive reply glic::mojom::WebClient::NotifyDefaultTabContextPermissionStateChanged";
      case messages::WebClient::kNotifyAdditionalContext:
            return "Receive reply glic::mojom::WebClient::NotifyAdditionalContext";
      case messages::WebClient::kNotifyActuationOnWebSettingChanged:
            return "Receive reply glic::mojom::WebClient::NotifyActuationOnWebSettingChanged";
      case messages::WebClient::kNotifyActOnWebCapabilityChanged:
            return "Receive reply glic::mojom::WebClient::NotifyActOnWebCapabilityChanged";
      case messages::WebClient::kNotifyOnboardingCompletedChanged:
            return "Receive reply glic::mojom::WebClient::NotifyOnboardingCompletedChanged";
      case messages::WebClient::kNotifyGeminiEnterpriseSettingsChanged:
            return "Receive reply glic::mojom::WebClient::NotifyGeminiEnterpriseSettingsChanged";
      case messages::WebClient::kNotifyActorTaskListRowClicked:
            return "Receive reply glic::mojom::WebClient::NotifyActorTaskListRowClicked";
      case messages::WebClient::kInvoke:
            return "Receive reply glic::mojom::WebClient::Invoke";
    }
  }
  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 WebClient::CheckResponsive_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 = 0x930063a8;  // IPCStableHash for glic::mojom::WebClient::CheckResponsive
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPanelWillOpen_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 = 0xb98b6bf3;  // IPCStableHash for glic::mojom::WebClient::NotifyPanelWillOpen
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPanelWasClosed_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 = 0x6298f317;  // IPCStableHash for glic::mojom::WebClient::NotifyPanelWasClosed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPanelStateChange_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 = 0xd3acd43e;  // IPCStableHash for glic::mojom::WebClient::NotifyPanelStateChange
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPanelActiveChange_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 = 0x63119508;  // IPCStableHash for glic::mojom::WebClient::NotifyPanelActiveChange
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPanelCanAttachChange_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 = 0xa4192190;  // IPCStableHash for glic::mojom::WebClient::NotifyPanelCanAttachChange
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyMicrophonePermissionStateChanged_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 = 0xf6db09ad;  // IPCStableHash for glic::mojom::WebClient::NotifyMicrophonePermissionStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyFileUploadStateChanged_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 = 0x065c6dcc;  // IPCStableHash for glic::mojom::WebClient::NotifyFileUploadStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::StopMicrophone_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 = 0x72c97d13;  // IPCStableHash for glic::mojom::WebClient::StopMicrophone
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyLocationPermissionStateChanged_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 = 0x44cfdef8;  // IPCStableHash for glic::mojom::WebClient::NotifyLocationPermissionStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyTabContextPermissionStateChanged_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 = 0xf90395f3;  // IPCStableHash for glic::mojom::WebClient::NotifyTabContextPermissionStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyOsLocationPermissionStateChanged_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 = 0xeacba04b;  // IPCStableHash for glic::mojom::WebClient::NotifyOsLocationPermissionStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyFocusedTabChanged_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 = 0xc23d08ad;  // IPCStableHash for glic::mojom::WebClient::NotifyFocusedTabChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyManualResizeChanged_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 = 0x2789b022;  // IPCStableHash for glic::mojom::WebClient::NotifyManualResizeChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyOsHotkeyStateChanged_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 = 0x6f94b4e1;  // IPCStableHash for glic::mojom::WebClient::NotifyOsHotkeyStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyBrowserIsOpenChanged_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 = 0xe68550fc;  // IPCStableHash for glic::mojom::WebClient::NotifyBrowserIsOpenChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyZoomLevelChanged_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 = 0x5314f024;  // IPCStableHash for glic::mojom::WebClient::NotifyZoomLevelChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyInstanceActivationChanged_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 = 0x7a6f4e48;  // IPCStableHash for glic::mojom::WebClient::NotifyInstanceActivationChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyClosedCaptioningSettingChanged_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 = 0xd0975143;  // IPCStableHash for glic::mojom::WebClient::NotifyClosedCaptioningSettingChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPinnedTabsChanged_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 = 0x0bd1a686;  // IPCStableHash for glic::mojom::WebClient::NotifyPinnedTabsChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPinnedTabDataChanged_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 = 0xb8964440;  // IPCStableHash for glic::mojom::WebClient::NotifyPinnedTabDataChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyPageMetadataChanged_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 = 0x47203df2;  // IPCStableHash for glic::mojom::WebClient::NotifyPageMetadataChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyDefaultTabContextPermissionStateChanged_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 = 0x6ef754c7;  // IPCStableHash for glic::mojom::WebClient::NotifyDefaultTabContextPermissionStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyAdditionalContext_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 = 0xf86f8984;  // IPCStableHash for glic::mojom::WebClient::NotifyAdditionalContext
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyActuationOnWebSettingChanged_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 = 0x62b21966;  // IPCStableHash for glic::mojom::WebClient::NotifyActuationOnWebSettingChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyActOnWebCapabilityChanged_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 = 0x74f9ff33;  // IPCStableHash for glic::mojom::WebClient::NotifyActOnWebCapabilityChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyOnboardingCompletedChanged_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 = 0x8e209344;  // IPCStableHash for glic::mojom::WebClient::NotifyOnboardingCompletedChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyGeminiEnterpriseSettingsChanged_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 = 0x93278fab;  // IPCStableHash for glic::mojom::WebClient::NotifyGeminiEnterpriseSettingsChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::NotifyActorTaskListRowClicked_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 = 0x8d3e5497;  // IPCStableHash for glic::mojom::WebClient::NotifyActorTaskListRowClicked
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t WebClient::Invoke_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 = 0x00ea274d;  // IPCStableHash for glic::mojom::WebClient::Invoke
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class WebClient_CheckResponsive_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClient_CheckResponsive_ForwardToCallback(
      WebClient::CheckResponsiveCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClient::CheckResponsiveCallback callback_;
};

class WebClient_NotifyPanelWillOpen_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClient_NotifyPanelWillOpen_ForwardToCallback(
      WebClient::NotifyPanelWillOpenCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClient::NotifyPanelWillOpenCallback callback_;
};

class WebClient_NotifyPanelWasClosed_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClient_NotifyPanelWasClosed_ForwardToCallback(
      WebClient::NotifyPanelWasClosedCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClient::NotifyPanelWasClosedCallback callback_;
};

class WebClient_StopMicrophone_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClient_StopMicrophone_ForwardToCallback(
      WebClient::StopMicrophoneCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClient::StopMicrophoneCallback callback_;
};

class WebClient_Invoke_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  WebClient_Invoke_ForwardToCallback(
      WebClient::InvokeCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  WebClient::InvokeCallback callback_;
};

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

void WebClientProxy::CheckResponsive(
    CheckResponsiveCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClient::CheckResponsive");
#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::WebClient::kCheckResponsive), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_CheckResponsive_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientProxy::NotifyPanelWillOpen(
    PanelOpeningDataPtr in_panel_opening_data, NotifyPanelWillOpenCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPanelWillOpen", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("panel_opening_data"), in_panel_opening_data,
                        "<value of type PanelOpeningDataPtr>");
   });
#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::WebClient::kNotifyPanelWillOpen), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelWillOpen_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->panel_opening_data)::BaseType> panel_opening_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::PanelOpeningDataDataView>(
    in_panel_opening_data,
    panel_opening_data_fragment);

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

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

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

void WebClientProxy::NotifyPanelWasClosed(
    NotifyPanelWasClosedCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClient::NotifyPanelWasClosed");
#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::WebClient::kNotifyPanelWasClosed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelWasClosed_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientProxy::NotifyPanelStateChange(
    PanelStatePtr in_panel_state) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPanelStateChange", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("panel_state"), in_panel_state,
                        "<value of type PanelStatePtr>");
   });
#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::WebClient::kNotifyPanelStateChange), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelStateChange_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->panel_state)::BaseType> panel_state_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::PanelStateDataView>(
    in_panel_state,
    panel_state_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPanelStateChange");
#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 WebClientProxy::NotifyPanelActiveChange(
    bool in_panel_active) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPanelActiveChange", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("panel_active"), in_panel_active,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyPanelActiveChange), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelActiveChange_Params_Data> params(
          message);
  params.Allocate();

  params->panel_active = in_panel_active;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPanelActiveChange");
#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 WebClientProxy::NotifyPanelCanAttachChange(
    bool in_can_attach) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPanelCanAttachChange", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("can_attach"), in_can_attach,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyPanelCanAttachChange), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelCanAttachChange_Params_Data> params(
          message);
  params.Allocate();

  params->can_attach = in_can_attach;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPanelCanAttachChange");
#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 WebClientProxy::NotifyMicrophonePermissionStateChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyMicrophonePermissionStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyMicrophonePermissionStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyMicrophonePermissionStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyMicrophonePermissionStateChanged");
#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 WebClientProxy::NotifyFileUploadStateChanged(
    FileUploadPolicyState in_state) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyFileUploadStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("state"), in_state,
                        "<value of type FileUploadPolicyState>");
   });
#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::WebClient::kNotifyFileUploadStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyFileUploadStateChanged_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::glic::mojom::FileUploadPolicyState>(
    in_state,
    &params->state);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyFileUploadStateChanged");
#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 WebClientProxy::StopMicrophone(
    StopMicrophoneCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::WebClient::StopMicrophone");
#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::WebClient::kStopMicrophone), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_StopMicrophone_Params_Data> params(
          message);
  params.Allocate();

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

void WebClientProxy::NotifyLocationPermissionStateChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyLocationPermissionStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyLocationPermissionStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyLocationPermissionStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyLocationPermissionStateChanged");
#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 WebClientProxy::NotifyTabContextPermissionStateChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyTabContextPermissionStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyTabContextPermissionStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyTabContextPermissionStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyTabContextPermissionStateChanged");
#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 WebClientProxy::NotifyOsLocationPermissionStateChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyOsLocationPermissionStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyOsLocationPermissionStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyOsLocationPermissionStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyOsLocationPermissionStateChanged");
#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 WebClientProxy::NotifyFocusedTabChanged(
    FocusedTabDataPtr in_focused_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyFocusedTabChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("focused_tab_data"), in_focused_tab_data,
                        "<value of type FocusedTabDataPtr>");
   });
#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::WebClient::kNotifyFocusedTabChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyFocusedTabChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->focused_tab_data)>
      focused_tab_data_fragment(params.message());
  focused_tab_data_fragment.Claim(&params->focused_tab_data);
  
  mojo::internal::Serialize<::glic::mojom::FocusedTabDataDataView>(
    in_focused_tab_data,
    focused_tab_data_fragment,
    true);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyFocusedTabChanged");
#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 WebClientProxy::NotifyManualResizeChanged(
    bool in_resizing) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyManualResizeChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("resizing"), in_resizing,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyManualResizeChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyManualResizeChanged_Params_Data> params(
          message);
  params.Allocate();

  params->resizing = in_resizing;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyManualResizeChanged");
#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 WebClientProxy::NotifyOsHotkeyStateChanged(
    const std::string& in_hotkey) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyOsHotkeyStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("hotkey"), in_hotkey,
                        "<value of type const std::string&>");
   });
#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::WebClient::kNotifyOsHotkeyStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyOsHotkeyStateChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->hotkey)::BaseType> hotkey_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_hotkey,
    hotkey_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyOsHotkeyStateChanged");
#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 WebClientProxy::NotifyBrowserIsOpenChanged(
    bool in_browser_is_open) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyBrowserIsOpenChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("browser_is_open"), in_browser_is_open,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyBrowserIsOpenChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyBrowserIsOpenChanged_Params_Data> params(
          message);
  params.Allocate();

  params->browser_is_open = in_browser_is_open;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyBrowserIsOpenChanged");
#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 WebClientProxy::NotifyZoomLevelChanged(
    double in_zoom_factor) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyZoomLevelChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("zoom_factor"), in_zoom_factor,
                        "<value of type double>");
   });
#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::WebClient::kNotifyZoomLevelChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyZoomLevelChanged_Params_Data> params(
          message);
  params.Allocate();

  params->zoom_factor = in_zoom_factor;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyZoomLevelChanged");
#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 WebClientProxy::NotifyInstanceActivationChanged(
    bool in_instance_active) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyInstanceActivationChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("instance_active"), in_instance_active,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyInstanceActivationChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyInstanceActivationChanged_Params_Data> params(
          message);
  params.Allocate();

  params->instance_active = in_instance_active;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyInstanceActivationChanged");
#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 WebClientProxy::NotifyClosedCaptioningSettingChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyClosedCaptioningSettingChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyClosedCaptioningSettingChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyClosedCaptioningSettingChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyClosedCaptioningSettingChanged");
#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 WebClientProxy::NotifyPinnedTabsChanged(
    std::vector<TabDataPtr> in_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPinnedTabsChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_data"), in_tab_data,
                        "<value of type std::vector<TabDataPtr>>");
   });
#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::WebClient::kNotifyPinnedTabsChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPinnedTabsChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_data)::BaseType>
      tab_data_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& tab_data_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::TabDataDataView>>(
    in_tab_data,
    tab_data_fragment,
    &tab_data_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPinnedTabsChanged");
#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 WebClientProxy::NotifyPinnedTabDataChanged(
    TabDataPtr in_tab_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPinnedTabDataChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_data"), in_tab_data,
                        "<value of type TabDataPtr>");
   });
#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::WebClient::kNotifyPinnedTabDataChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPinnedTabDataChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_data)::BaseType> tab_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TabDataDataView>(
    in_tab_data,
    tab_data_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPinnedTabDataChanged");
#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 WebClientProxy::NotifyPageMetadataChanged(
    int32_t in_tab_id, ::blink::mojom::PageMetadataPtr in_metadata) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyPageMetadataChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("metadata"), in_metadata,
                        "<value of type ::blink::mojom::PageMetadataPtr>");
   });
#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::WebClient::kNotifyPageMetadataChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPageMetadataChanged_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->metadata)::BaseType> metadata_fragment(
          params.message());
  
  mojo::internal::Serialize<::blink::mojom::PageMetadataDataView>(
    in_metadata,
    metadata_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPageMetadataChanged");
#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 WebClientProxy::NotifyDefaultTabContextPermissionStateChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyDefaultTabContextPermissionStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyDefaultTabContextPermissionStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyDefaultTabContextPermissionStateChanged");
#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 WebClientProxy::NotifyAdditionalContext(
    AdditionalContextPtr in_context) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyAdditionalContext", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("context"), in_context,
                        "<value of type AdditionalContextPtr>");
   });
#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::WebClient::kNotifyAdditionalContext), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyAdditionalContext_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->context)::BaseType> context_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::AdditionalContextDataView>(
    in_context,
    context_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyAdditionalContext");
#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 WebClientProxy::NotifyActuationOnWebSettingChanged(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyActuationOnWebSettingChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyActuationOnWebSettingChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyActuationOnWebSettingChanged_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyActuationOnWebSettingChanged");
#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 WebClientProxy::NotifyActOnWebCapabilityChanged(
    bool in_can_act_on_web) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyActOnWebCapabilityChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("can_act_on_web"), in_can_act_on_web,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyActOnWebCapabilityChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyActOnWebCapabilityChanged_Params_Data> params(
          message);
  params.Allocate();

  params->can_act_on_web = in_can_act_on_web;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyActOnWebCapabilityChanged");
#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 WebClientProxy::NotifyOnboardingCompletedChanged(
    bool in_completed) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyOnboardingCompletedChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("completed"), in_completed,
                        "<value of type bool>");
   });
#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::WebClient::kNotifyOnboardingCompletedChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyOnboardingCompletedChanged_Params_Data> params(
          message);
  params.Allocate();

  params->completed = in_completed;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyOnboardingCompletedChanged");
#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 WebClientProxy::NotifyGeminiEnterpriseSettingsChanged(
    GeminiEnterpriseSettingsPtr in_settings) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyGeminiEnterpriseSettingsChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("settings"), in_settings,
                        "<value of type GeminiEnterpriseSettingsPtr>");
   });
#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::WebClient::kNotifyGeminiEnterpriseSettingsChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->settings)::BaseType> settings_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::GeminiEnterpriseSettingsDataView>(
    in_settings,
    settings_fragment);

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyGeminiEnterpriseSettingsChanged");
#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 WebClientProxy::NotifyActorTaskListRowClicked(
    int32_t in_task_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::NotifyActorTaskListRowClicked", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type int32_t>");
   });
#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::WebClient::kNotifyActorTaskListRowClicked), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyActorTaskListRowClicked_Params_Data> params(
          message);
  params.Allocate();

  params->task_id = in_task_id;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyActorTaskListRowClicked");
#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 WebClientProxy::Invoke(
    InvokeOptionsPtr in_options, InvokeCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::WebClient::Invoke", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type InvokeOptionsPtr>");
   });
#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::WebClient::kInvoke), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_Invoke_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::InvokeOptionsDataView>(
    in_options,
    options_fragment);

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

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

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

  ~WebClient_CheckResponsive_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:
  WebClient_CheckResponsive_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)
        << "WebClient::CheckResponsiveCallback 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 WebClient_CheckResponsive_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClient_CheckResponsive_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClient_CheckResponsive_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClient_CheckResponsive_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClient::CheckResponsive");
#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::WebClient::kCheckResponsive), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_CheckResponsive_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("CheckResponsive");
#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 WebClient_NotifyPanelWillOpen_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClient::NotifyPanelWillOpenCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClient_NotifyPanelWillOpen_ProxyToResponder> proxy(
        new WebClient_NotifyPanelWillOpen_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClient_NotifyPanelWillOpen_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClient_NotifyPanelWillOpen_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:
  WebClient_NotifyPanelWillOpen_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)
        << "WebClient::NotifyPanelWillOpenCallback 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(
      OpenPanelInfoPtr in_openPanelInfo);
};

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

  // Validation for WebClient.1
  bool success = true;
  OpenPanelInfoPtr p_openPanelInfo{};
  WebClient_NotifyPanelWillOpen_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadOpenPanelInfo(&p_openPanelInfo))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        WebClient::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_openPanelInfo));
  }
  return true;
}

void WebClient_NotifyPanelWillOpen_ProxyToResponder::Run(
    OpenPanelInfoPtr in_openPanelInfo) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::WebClient::NotifyPanelWillOpen", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("openPanelInfo"), in_openPanelInfo,
                        "<value of type OpenPanelInfoPtr>");
   });
#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::WebClient::kNotifyPanelWillOpen), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelWillOpen_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->openPanelInfo)::BaseType> openPanelInfo_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::OpenPanelInfoDataView>(
    in_openPanelInfo,
    openPanelInfo_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPanelWillOpen");
#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 WebClient_NotifyPanelWasClosed_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClient::NotifyPanelWasClosedCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClient_NotifyPanelWasClosed_ProxyToResponder> proxy(
        new WebClient_NotifyPanelWasClosed_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClient_NotifyPanelWasClosed_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClient_NotifyPanelWasClosed_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:
  WebClient_NotifyPanelWasClosed_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)
        << "WebClient::NotifyPanelWasClosedCallback 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 WebClient_NotifyPanelWasClosed_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClient_NotifyPanelWasClosed_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClient_NotifyPanelWasClosed_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClient_NotifyPanelWasClosed_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClient::NotifyPanelWasClosed");
#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::WebClient::kNotifyPanelWasClosed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_NotifyPanelWasClosed_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("NotifyPanelWasClosed");
#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 WebClient_StopMicrophone_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClient::StopMicrophoneCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClient_StopMicrophone_ProxyToResponder> proxy(
        new WebClient_StopMicrophone_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClient_StopMicrophone_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClient_StopMicrophone_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:
  WebClient_StopMicrophone_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)
        << "WebClient::StopMicrophoneCallback 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 WebClient_StopMicrophone_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClient_StopMicrophone_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClient_StopMicrophone_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClient_StopMicrophone_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClient::StopMicrophone");
#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::WebClient::kStopMicrophone), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_StopMicrophone_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("StopMicrophone");
#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 WebClient_Invoke_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static WebClient::InvokeCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<WebClient_Invoke_ProxyToResponder> proxy(
        new WebClient_Invoke_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&WebClient_Invoke_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~WebClient_Invoke_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:
  WebClient_Invoke_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)
        << "WebClient::InvokeCallback 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 WebClient_Invoke_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::WebClient_Invoke_ResponseParams_Data* params =
      reinterpret_cast<
          internal::WebClient_Invoke_ResponseParams_Data*>(
              message->mutable_payload());
  

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

void WebClient_Invoke_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply glic::mojom::WebClient::Invoke");
#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::WebClient::kInvoke), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::WebClient_Invoke_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(WebClient::Name_);
  message.set_method_name("Invoke");
#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 WebClientStubDispatch::Accept(
    WebClient* impl,
    mojo::Message* message) {
  switch (static_cast<messages::WebClient>(message->header()->name)) {
    case messages::WebClient::kCheckResponsive: {
      break;
    }
    case messages::WebClient::kNotifyPanelWillOpen: {
      break;
    }
    case messages::WebClient::kNotifyPanelWasClosed: {
      break;
    }
    case messages::WebClient::kNotifyPanelStateChange: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyPanelStateChange_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyPanelStateChange_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.3
      bool success = true;
      PanelStatePtr p_panel_state{};
      WebClient_NotifyPanelStateChange_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadPanelState(&p_panel_state))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPanelStateChange(        
        std::move(p_panel_state));
      return true;
    }
    case messages::WebClient::kNotifyPanelActiveChange: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyPanelActiveChange_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyPanelActiveChange_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.4
      bool success = true;
      bool p_panel_active{};
      WebClient_NotifyPanelActiveChange_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_panel_active = input_data_view.panel_active();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPanelActiveChange(        
        std::move(p_panel_active));
      return true;
    }
    case messages::WebClient::kNotifyPanelCanAttachChange: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyPanelCanAttachChange_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyPanelCanAttachChange_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.5
      bool success = true;
      bool p_can_attach{};
      WebClient_NotifyPanelCanAttachChange_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_can_attach = input_data_view.can_attach();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 5, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPanelCanAttachChange(        
        std::move(p_can_attach));
      return true;
    }
    case messages::WebClient::kNotifyMicrophonePermissionStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyMicrophonePermissionStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyMicrophonePermissionStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.6
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyMicrophonePermissionStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 6, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyMicrophonePermissionStateChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyFileUploadStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyFileUploadStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyFileUploadStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.7
      bool success = true;
      FileUploadPolicyState p_state{};
      WebClient_NotifyFileUploadStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadState(&p_state))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 7, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyFileUploadStateChanged(        
        std::move(p_state));
      return true;
    }
    case messages::WebClient::kStopMicrophone: {
      break;
    }
    case messages::WebClient::kNotifyLocationPermissionStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyLocationPermissionStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyLocationPermissionStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.9
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyLocationPermissionStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 9, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyLocationPermissionStateChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyTabContextPermissionStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyTabContextPermissionStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyTabContextPermissionStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.10
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyTabContextPermissionStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 10, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyTabContextPermissionStateChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyOsLocationPermissionStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyOsLocationPermissionStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyOsLocationPermissionStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.11
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyOsLocationPermissionStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 11, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyOsLocationPermissionStateChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyFocusedTabChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyFocusedTabChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyFocusedTabChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.12
      bool success = true;
      FocusedTabDataPtr p_focused_tab_data{};
      WebClient_NotifyFocusedTabChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadFocusedTabData(&p_focused_tab_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 12, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyFocusedTabChanged(        
        std::move(p_focused_tab_data));
      return true;
    }
    case messages::WebClient::kNotifyManualResizeChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyManualResizeChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyManualResizeChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.13
      bool success = true;
      bool p_resizing{};
      WebClient_NotifyManualResizeChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_resizing = input_data_view.resizing();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 13, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyManualResizeChanged(        
        std::move(p_resizing));
      return true;
    }
    case messages::WebClient::kNotifyOsHotkeyStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyOsHotkeyStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyOsHotkeyStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.14
      bool success = true;
      std::string p_hotkey{};
      WebClient_NotifyOsHotkeyStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadHotkey(&p_hotkey))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 14, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyOsHotkeyStateChanged(        
        std::move(p_hotkey));
      return true;
    }
    case messages::WebClient::kNotifyBrowserIsOpenChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyBrowserIsOpenChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyBrowserIsOpenChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.15
      bool success = true;
      bool p_browser_is_open{};
      WebClient_NotifyBrowserIsOpenChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_browser_is_open = input_data_view.browser_is_open();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 15, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyBrowserIsOpenChanged(        
        std::move(p_browser_is_open));
      return true;
    }
    case messages::WebClient::kNotifyZoomLevelChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyZoomLevelChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyZoomLevelChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.16
      bool success = true;
      double p_zoom_factor{};
      WebClient_NotifyZoomLevelChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_zoom_factor = input_data_view.zoom_factor();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 16, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyZoomLevelChanged(        
        std::move(p_zoom_factor));
      return true;
    }
    case messages::WebClient::kNotifyInstanceActivationChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyInstanceActivationChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyInstanceActivationChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.17
      bool success = true;
      bool p_instance_active{};
      WebClient_NotifyInstanceActivationChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_instance_active = input_data_view.instance_active();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 17, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyInstanceActivationChanged(        
        std::move(p_instance_active));
      return true;
    }
    case messages::WebClient::kNotifyClosedCaptioningSettingChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyClosedCaptioningSettingChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyClosedCaptioningSettingChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.18
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyClosedCaptioningSettingChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 18, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyClosedCaptioningSettingChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyPinnedTabsChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyPinnedTabsChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyPinnedTabsChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.19
      bool success = true;
      std::vector<TabDataPtr> p_tab_data{};
      WebClient_NotifyPinnedTabsChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTabData(&p_tab_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 19, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPinnedTabsChanged(        
        std::move(p_tab_data));
      return true;
    }
    case messages::WebClient::kNotifyPinnedTabDataChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyPinnedTabDataChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyPinnedTabDataChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.20
      bool success = true;
      TabDataPtr p_tab_data{};
      WebClient_NotifyPinnedTabDataChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTabData(&p_tab_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 20, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPinnedTabDataChanged(        
        std::move(p_tab_data));
      return true;
    }
    case messages::WebClient::kNotifyPageMetadataChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyPageMetadataChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyPageMetadataChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.21
      bool success = true;
      int32_t p_tab_id{};
      ::blink::mojom::PageMetadataPtr p_metadata{};
      WebClient_NotifyPageMetadataChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadMetadata(&p_metadata))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 21, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPageMetadataChanged(        
        std::move(p_tab_id), 
        std::move(p_metadata));
      return true;
    }
    case messages::WebClient::kNotifyDefaultTabContextPermissionStateChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.22
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyDefaultTabContextPermissionStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 22, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyDefaultTabContextPermissionStateChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyAdditionalContext: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyAdditionalContext_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyAdditionalContext_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.23
      bool success = true;
      AdditionalContextPtr p_context{};
      WebClient_NotifyAdditionalContext_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadContext(&p_context))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 23, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyAdditionalContext(        
        std::move(p_context));
      return true;
    }
    case messages::WebClient::kNotifyActuationOnWebSettingChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyActuationOnWebSettingChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyActuationOnWebSettingChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.24
      bool success = true;
      bool p_enabled{};
      WebClient_NotifyActuationOnWebSettingChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 24, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyActuationOnWebSettingChanged(        
        std::move(p_enabled));
      return true;
    }
    case messages::WebClient::kNotifyActOnWebCapabilityChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyActOnWebCapabilityChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyActOnWebCapabilityChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.25
      bool success = true;
      bool p_can_act_on_web{};
      WebClient_NotifyActOnWebCapabilityChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_can_act_on_web = input_data_view.can_act_on_web();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 25, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyActOnWebCapabilityChanged(        
        std::move(p_can_act_on_web));
      return true;
    }
    case messages::WebClient::kNotifyOnboardingCompletedChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyOnboardingCompletedChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyOnboardingCompletedChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.26
      bool success = true;
      bool p_completed{};
      WebClient_NotifyOnboardingCompletedChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_completed = input_data_view.completed();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 26, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyOnboardingCompletedChanged(        
        std::move(p_completed));
      return true;
    }
    case messages::WebClient::kNotifyGeminiEnterpriseSettingsChanged: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.27
      bool success = true;
      GeminiEnterpriseSettingsPtr p_settings{};
      WebClient_NotifyGeminiEnterpriseSettingsChanged_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSettings(&p_settings))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 27, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyGeminiEnterpriseSettingsChanged(        
        std::move(p_settings));
      return true;
    }
    case messages::WebClient::kNotifyActorTaskListRowClicked: {
      DCHECK(message->is_serialized());
      internal::WebClient_NotifyActorTaskListRowClicked_Params_Data* params =
          reinterpret_cast<internal::WebClient_NotifyActorTaskListRowClicked_Params_Data*>(
              message->mutable_payload());
      

      // Validation for WebClient.28
      bool success = true;
      int32_t p_task_id{};
      WebClient_NotifyActorTaskListRowClicked_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_task_id = input_data_view.task_id();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 28, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyActorTaskListRowClicked(        
        std::move(p_task_id));
      return true;
    }
    case messages::WebClient::kInvoke: {
      break;
    }
  }
  return false;
}

// static
bool WebClientStubDispatch::AcceptWithResponder(
    WebClient* 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::WebClient>(message->header()->name)) {
    case messages::WebClient::kCheckResponsive: {
      internal::WebClient_CheckResponsive_Params_Data* params =
          reinterpret_cast<
              internal::WebClient_CheckResponsive_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClient.0
      bool success = true;
      WebClient_CheckResponsive_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 0, false);
        return false;
      }
      auto callback =
          WebClient_CheckResponsive_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CheckResponsive(std::move(callback));
      return true;
    }
    case messages::WebClient::kNotifyPanelWillOpen: {
      internal::WebClient_NotifyPanelWillOpen_Params_Data* params =
          reinterpret_cast<
              internal::WebClient_NotifyPanelWillOpen_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClient.1
      bool success = true;
      PanelOpeningDataPtr p_panel_opening_data{};
      WebClient_NotifyPanelWillOpen_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadPanelOpeningData(&p_panel_opening_data))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 1, false);
        return false;
      }
      auto callback =
          WebClient_NotifyPanelWillOpen_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPanelWillOpen(        
        std::move(p_panel_opening_data), std::move(callback));
      return true;
    }
    case messages::WebClient::kNotifyPanelWasClosed: {
      internal::WebClient_NotifyPanelWasClosed_Params_Data* params =
          reinterpret_cast<
              internal::WebClient_NotifyPanelWasClosed_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClient.2
      bool success = true;
      WebClient_NotifyPanelWasClosed_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 2, false);
        return false;
      }
      auto callback =
          WebClient_NotifyPanelWasClosed_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifyPanelWasClosed(std::move(callback));
      return true;
    }
    case messages::WebClient::kNotifyPanelStateChange: {
      break;
    }
    case messages::WebClient::kNotifyPanelActiveChange: {
      break;
    }
    case messages::WebClient::kNotifyPanelCanAttachChange: {
      break;
    }
    case messages::WebClient::kNotifyMicrophonePermissionStateChanged: {
      break;
    }
    case messages::WebClient::kNotifyFileUploadStateChanged: {
      break;
    }
    case messages::WebClient::kStopMicrophone: {
      internal::WebClient_StopMicrophone_Params_Data* params =
          reinterpret_cast<
              internal::WebClient_StopMicrophone_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClient.8
      bool success = true;
      WebClient_StopMicrophone_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 8, false);
        return false;
      }
      auto callback =
          WebClient_StopMicrophone_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->StopMicrophone(std::move(callback));
      return true;
    }
    case messages::WebClient::kNotifyLocationPermissionStateChanged: {
      break;
    }
    case messages::WebClient::kNotifyTabContextPermissionStateChanged: {
      break;
    }
    case messages::WebClient::kNotifyOsLocationPermissionStateChanged: {
      break;
    }
    case messages::WebClient::kNotifyFocusedTabChanged: {
      break;
    }
    case messages::WebClient::kNotifyManualResizeChanged: {
      break;
    }
    case messages::WebClient::kNotifyOsHotkeyStateChanged: {
      break;
    }
    case messages::WebClient::kNotifyBrowserIsOpenChanged: {
      break;
    }
    case messages::WebClient::kNotifyZoomLevelChanged: {
      break;
    }
    case messages::WebClient::kNotifyInstanceActivationChanged: {
      break;
    }
    case messages::WebClient::kNotifyClosedCaptioningSettingChanged: {
      break;
    }
    case messages::WebClient::kNotifyPinnedTabsChanged: {
      break;
    }
    case messages::WebClient::kNotifyPinnedTabDataChanged: {
      break;
    }
    case messages::WebClient::kNotifyPageMetadataChanged: {
      break;
    }
    case messages::WebClient::kNotifyDefaultTabContextPermissionStateChanged: {
      break;
    }
    case messages::WebClient::kNotifyAdditionalContext: {
      break;
    }
    case messages::WebClient::kNotifyActuationOnWebSettingChanged: {
      break;
    }
    case messages::WebClient::kNotifyActOnWebCapabilityChanged: {
      break;
    }
    case messages::WebClient::kNotifyOnboardingCompletedChanged: {
      break;
    }
    case messages::WebClient::kNotifyGeminiEnterpriseSettingsChanged: {
      break;
    }
    case messages::WebClient::kNotifyActorTaskListRowClicked: {
      break;
    }
    case messages::WebClient::kInvoke: {
      internal::WebClient_Invoke_Params_Data* params =
          reinterpret_cast<
              internal::WebClient_Invoke_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for WebClient.29
      bool success = true;
      InvokeOptionsPtr p_options{};
      WebClient_Invoke_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            WebClient::Name_, 29, false);
        return false;
      }
      auto callback =
          WebClient_Invoke_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->Invoke(        
        std::move(p_options), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kWebClientValidationInfo[] = {
    { &internal::WebClient_CheckResponsive_Params_Data::Validate,
     &internal::WebClient_CheckResponsive_ResponseParams_Data::Validate},
    { &internal::WebClient_NotifyPanelWillOpen_Params_Data::Validate,
     &internal::WebClient_NotifyPanelWillOpen_ResponseParams_Data::Validate},
    { &internal::WebClient_NotifyPanelWasClosed_Params_Data::Validate,
     &internal::WebClient_NotifyPanelWasClosed_ResponseParams_Data::Validate},
    { &internal::WebClient_NotifyPanelStateChange_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyPanelActiveChange_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyPanelCanAttachChange_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyMicrophonePermissionStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyFileUploadStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_StopMicrophone_Params_Data::Validate,
     &internal::WebClient_StopMicrophone_ResponseParams_Data::Validate},
    { &internal::WebClient_NotifyLocationPermissionStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyTabContextPermissionStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyOsLocationPermissionStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyFocusedTabChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyManualResizeChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyOsHotkeyStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyBrowserIsOpenChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyZoomLevelChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyInstanceActivationChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyClosedCaptioningSettingChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyPinnedTabsChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyPinnedTabDataChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyPageMetadataChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyAdditionalContext_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyActuationOnWebSettingChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyActOnWebCapabilityChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyOnboardingCompletedChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_NotifyActorTaskListRowClicked_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::WebClient_Invoke_Params_Data::Validate,
     &internal::WebClient_Invoke_ResponseParams_Data::Validate},
};

bool WebClientRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::WebClient::Name_,
    kWebClientValidationInfo);
}

bool WebClientResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::glic::mojom::WebClient::Name_,
    kWebClientValidationInfo);
}
// The declaration includes the definition on other builds.

CaptureRegionObserver::IPCStableHashFunction CaptureRegionObserver::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::CaptureRegionObserver>(message.name())) {
    case messages::CaptureRegionObserver::kOnUpdate: {
      return &CaptureRegionObserver::OnUpdate_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* CaptureRegionObserver::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::CaptureRegionObserver>(message.name())) {
      case messages::CaptureRegionObserver::kOnUpdate:
            return "Receive glic::mojom::CaptureRegionObserver::OnUpdate";
    }
  } else {
    switch (static_cast<messages::CaptureRegionObserver>(message.name())) {
      case messages::CaptureRegionObserver::kOnUpdate:
            return "Receive reply glic::mojom::CaptureRegionObserver::OnUpdate";
    }
  }
  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 CaptureRegionObserver::OnUpdate_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 = 0x46757482;  // IPCStableHash for glic::mojom::CaptureRegionObserver::OnUpdate
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void CaptureRegionObserverProxy::OnUpdate(
    CaptureRegionResultPtr in_result, std::optional<CaptureRegionErrorReason> in_reason) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::CaptureRegionObserver::OnUpdate", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type CaptureRegionResultPtr>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("reason"), in_reason,
                        "<value of type std::optional<CaptureRegionErrorReason>>");
   });
#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::CaptureRegionObserver::kOnUpdate), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::CaptureRegionObserver_OnUpdate_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->result)::BaseType> result_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::CaptureRegionResultDataView>(
    in_result,
    result_fragment);

  params->result.Set(
      result_fragment.is_null() ? nullptr : result_fragment.data());
  params->reason_$flag = in_reason.has_value();
  if (in_reason.has_value()) {
    
    mojo::internal::Serialize<::glic::mojom::CaptureRegionErrorReason>(
      in_reason.value(),
      &params->reason_$value);
  } else {
    params->reason_$value =
        static_cast<int32_t>(::glic::mojom::CaptureRegionErrorReason::kMinValue);
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(CaptureRegionObserver::Name_);
  message.set_method_name("OnUpdate");
#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 CaptureRegionObserverStubDispatch::Accept(
    CaptureRegionObserver* impl,
    mojo::Message* message) {
  switch (static_cast<messages::CaptureRegionObserver>(message->header()->name)) {
    case messages::CaptureRegionObserver::kOnUpdate: {
      DCHECK(message->is_serialized());
      internal::CaptureRegionObserver_OnUpdate_Params_Data* params =
          reinterpret_cast<internal::CaptureRegionObserver_OnUpdate_Params_Data*>(
              message->mutable_payload());
      

      // Validation for CaptureRegionObserver.0
      bool success = true;
      CaptureRegionResultPtr p_result{};
      std::optional<CaptureRegionErrorReason> p_reason{};
      CaptureRegionObserver_OnUpdate_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadResult(&p_result))
        success = false;
      if (success && !input_data_view.ReadReason(&p_reason)) {
        success = false;
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            CaptureRegionObserver::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnUpdate(        
        std::move(p_result), 
        std::move(p_reason));
      return true;
    }
  }
  return false;
}

// static
bool CaptureRegionObserverStubDispatch::AcceptWithResponder(
    CaptureRegionObserver* 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::CaptureRegionObserver>(message->header()->name)) {
    case messages::CaptureRegionObserver::kOnUpdate: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kCaptureRegionObserverValidationInfo[] = {
    { &internal::CaptureRegionObserver_OnUpdate_Params_Data::Validate,
     nullptr /* no response */},
};

bool CaptureRegionObserverRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::CaptureRegionObserver::Name_,
    kCaptureRegionObserverValidationInfo);
}



}  // glic::mojom


namespace mojo {


// static
bool StructTraits<::glic::mojom::GeminiEnterpriseSettings::DataView, ::glic::mojom::GeminiEnterpriseSettingsPtr>::Read(
    ::glic::mojom::GeminiEnterpriseSettings::DataView input,
    ::glic::mojom::GeminiEnterpriseSettingsPtr* output) {
  bool success = true;
  ::glic::mojom::GeminiEnterpriseSettingsPtr result(::glic::mojom::GeminiEnterpriseSettings::New());
  
      if (success && !input.ReadProjectId(&result->project_id))
        success = false;
      if (success && !input.ReadAppId(&result->app_id))
        success = false;
      if (success && !input.ReadLocation(&result->location))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ProfileEnablement::DataView, ::glic::mojom::ProfileEnablementPtr>::Read(
    ::glic::mojom::ProfileEnablement::DataView input,
    ::glic::mojom::ProfileEnablementPtr* output) {
  bool success = true;
  ::glic::mojom::ProfileEnablementPtr result(::glic::mojom::ProfileEnablement::New());
  
      if (success)
        result->feature_enabled = input.feature_enabled();
      if (success)
        result->is_regular_profile = input.is_regular_profile();
      if (success)
        result->is_rolled_out = input.is_rolled_out();
      if (success)
        result->primary_account_is_capable = input.primary_account_is_capable();
      if (success)
        result->primary_account_is_fully_signed_in = input.primary_account_is_fully_signed_in();
      if (success)
        result->allowed_by_chrome_policy = input.allowed_by_chrome_policy();
      if (success)
        result->allowed_by_remote_admin = input.allowed_by_remote_admin();
      if (success)
        result->allowed_by_remote_other = input.allowed_by_remote_other();
      if (success)
        result->fre_is_consented = input.fre_is_consented();
      if (success)
        result->allowed_by_country_filter = input.allowed_by_country_filter();
      if (success)
        result->allowed_by_locale_filter = input.allowed_by_locale_filter();
      if (success)
        result->actuation_is_consented = input.actuation_is_consented();
      if (success)
        result->live_allowed = input.live_allowed();
      if (success)
        result->share_image_allowed = input.share_image_allowed();
      if (success && !input.ReadGeminiEnterpriseSettings(&result->gemini_enterprise_settings))
        success = false;
      if (success && !input.ReadActuationEligibility(&result->actuation_eligibility))
        success = false;
      if (success && !input.ReadGlicApiActuationEligibility(&result->glic_api_actuation_eligibility))
        success = false;
      if (success && !input.ReadGlicExperimentalTriggeringState(&result->glic_experimental_triggering_state))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ConfigInfo::DataView, ::glic::mojom::ConfigInfoPtr>::Read(
    ::glic::mojom::ConfigInfo::DataView input,
    ::glic::mojom::ConfigInfoPtr* output) {
  bool success = true;
  ::glic::mojom::ConfigInfoPtr result(::glic::mojom::ConfigInfo::New());
  
      if (success && !input.ReadGuestUrl(&result->guest_url))
        success = false;
      if (success && !input.ReadAutopushGuestUrl(&result->autopush_guest_url))
        success = false;
      if (success && !input.ReadStagingGuestUrl(&result->staging_guest_url))
        success = false;
      if (success && !input.ReadPreprodGuestUrl(&result->preprod_guest_url))
        success = false;
      if (success && !input.ReadProdGuestUrl(&result->prod_guest_url))
        success = false;
      if (success && !input.ReadWebContinuityOriginatingHostUrl(&result->web_continuity_originating_host_url))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::DefaultConversation::DataView, ::glic::mojom::DefaultConversationPtr>::Read(
    ::glic::mojom::DefaultConversation::DataView input,
    ::glic::mojom::DefaultConversationPtr* output) {
  bool success = true;
  ::glic::mojom::DefaultConversationPtr result(::glic::mojom::DefaultConversation::New());
  
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::NewConversation::DataView, ::glic::mojom::NewConversationPtr>::Read(
    ::glic::mojom::NewConversation::DataView input,
    ::glic::mojom::NewConversationPtr* output) {
  bool success = true;
  ::glic::mojom::NewConversationPtr result(::glic::mojom::NewConversation::New());
  
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::DefaultSurfaceMojo::DataView, ::glic::mojom::DefaultSurfaceMojoPtr>::Read(
    ::glic::mojom::DefaultSurfaceMojo::DataView input,
    ::glic::mojom::DefaultSurfaceMojoPtr* output) {
  bool success = true;
  ::glic::mojom::DefaultSurfaceMojoPtr result(::glic::mojom::DefaultSurfaceMojo::New());
  
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::NewTabMojo::DataView, ::glic::mojom::NewTabMojoPtr>::Read(
    ::glic::mojom::NewTabMojo::DataView input,
    ::glic::mojom::NewTabMojoPtr* output) {
  bool success = true;
  ::glic::mojom::NewTabMojoPtr result(::glic::mojom::NewTabMojo::New());
  
      if (success)
        result->open_in_foreground = input.open_in_foreground();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ZssConfig::DataView, ::glic::mojom::ZssConfigPtr>::Read(
    ::glic::mojom::ZssConfig::DataView input,
    ::glic::mojom::ZssConfigPtr* output) {
  bool success = true;
  ::glic::mojom::ZssConfigPtr result(::glic::mojom::ZssConfig::New());
  
      if (success && !input.ReadAdditionalContent(&result->additional_content))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::GetContextResultWithActionResultCode::DataView, ::glic::mojom::GetContextResultWithActionResultCodePtr>::Read(
    ::glic::mojom::GetContextResultWithActionResultCode::DataView input,
    ::glic::mojom::GetContextResultWithActionResultCodePtr* output) {
  bool success = true;
  ::glic::mojom::GetContextResultWithActionResultCodePtr result(::glic::mojom::GetContextResultWithActionResultCode::New());
  
      if (success && !input.ReadGetContextResult(&result->get_context_result))
        success = false;
      if (success) {
        result->action_result = input.action_result();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::UserProfileInfo::DataView, ::glic::mojom::UserProfileInfoPtr>::Read(
    ::glic::mojom::UserProfileInfo::DataView input,
    ::glic::mojom::UserProfileInfoPtr* output) {
  bool success = true;
  ::glic::mojom::UserProfileInfoPtr result(::glic::mojom::UserProfileInfo::New());
  
      if (success && !input.ReadAvatarIcon(&result->avatar_icon))
        success = false;
      if (success && !input.ReadDisplayName(&result->display_name))
        success = false;
      if (success && !input.ReadGivenName(&result->given_name))
        success = false;
      if (success && !input.ReadLocalProfileName(&result->local_profile_name))
        success = false;
      if (success && !input.ReadEmail(&result->email))
        success = false;
      if (success)
        result->is_managed = input.is_managed();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::SafeBrowsingVerdict::DataView, ::glic::mojom::SafeBrowsingVerdictPtr>::Read(
    ::glic::mojom::SafeBrowsingVerdict::DataView input,
    ::glic::mojom::SafeBrowsingVerdictPtr* output) {
  bool success = true;
  ::glic::mojom::SafeBrowsingVerdictPtr result(::glic::mojom::SafeBrowsingVerdict::New());
  
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadThreatType(&result->threat_type))
        success = false;
      if (success)
        result->show_interstitial = input.show_interstitial();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::CounterAbuseVerdict::DataView, ::glic::mojom::CounterAbuseVerdictPtr>::Read(
    ::glic::mojom::CounterAbuseVerdict::DataView input,
    ::glic::mojom::CounterAbuseVerdictPtr* output) {
  bool success = true;
  ::glic::mojom::CounterAbuseVerdictPtr result(::glic::mojom::CounterAbuseVerdict::New());
  
      if (success && !input.ReadSbVerdictResult(&result->sb_verdict_result))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::WebClientInitialState::DataView, ::glic::mojom::WebClientInitialStatePtr>::Read(
    ::glic::mojom::WebClientInitialState::DataView input,
    ::glic::mojom::WebClientInitialStatePtr* output) {
  bool success = true;
  ::glic::mojom::WebClientInitialStatePtr result(::glic::mojom::WebClientInitialState::New());
  
      if (success && !input.ReadPanelState(&result->panel_state))
        success = false;
      if (success && !input.ReadFocusedTabData(&result->focused_tab_data))
        success = false;
      if (success)
        result->microphone_permission_enabled = input.microphone_permission_enabled();
      if (success)
        result->location_permission_enabled = input.location_permission_enabled();
      if (success)
        result->tab_context_permission_enabled = input.tab_context_permission_enabled();
      if (success)
        result->os_location_permission_enabled = input.os_location_permission_enabled();
      if (success)
        result->zoom_factor = input.zoom_factor();
      if (success && !input.ReadHotkey(&result->hotkey))
        success = false;
      if (success && !input.ReadChromeVersion(&result->chrome_version))
        success = false;
      if (success && !input.ReadPlatform(&result->platform))
        success = false;
      if (success && !input.ReadFormFactor(&result->form_factor))
        success = false;
      if (success)
        result->can_attach = input.can_attach();
      if (success)
        result->panel_is_active = input.panel_is_active();
      if (success)
        result->browser_is_open = input.browser_is_open();
      if (success)
        result->instance_is_active = input.instance_is_active();
      if (success)
        result->enable_zero_state_suggestions = input.enable_zero_state_suggestions();
      if (success)
        result->enable_cached_get_user_profile_info = input.enable_cached_get_user_profile_info();
      if (success)
        result->enable_act_in_focused_tab = input.enable_act_in_focused_tab();
      if (success)
        result->enable_scroll_to = input.enable_scroll_to();
      if (success)
        result->enable_default_tab_context_setting_feature = input.enable_default_tab_context_setting_feature();
      if (success)
        result->default_tab_context_setting_enabled = input.default_tab_context_setting_enabled();
      if (success)
        result->closed_captioning_setting_enabled = input.closed_captioning_setting_enabled();
      if (success)
        result->enable_maybe_refresh_user_status = input.enable_maybe_refresh_user_status();
      if (success)
        result->enable_multi_tab = input.enable_multi_tab();
      if (success)
        result->enable_get_context_actor = input.enable_get_context_actor();
      if (success && !input.ReadHostCapabilities(&result->host_capabilities))
        success = false;
      if (success)
        result->enable_get_page_metadata = input.enable_get_page_metadata();
      if (success)
        result->enable_capture_region = input.enable_capture_region();
      if (success)
        result->enable_web_actuation_setting_feature = input.enable_web_actuation_setting_feature();
      if (success)
        result->actuation_on_web_setting_enabled = input.actuation_on_web_setting_enabled();
      if (success)
        result->can_act_on_web = input.can_act_on_web();
      if (success)
        result->enable_activate_tab = input.enable_activate_tab();
      if (success)
        result->enable_get_tab_by_id = input.enable_get_tab_by_id();
      if (success)
        result->enable_open_password_manager_settings_page = input.enable_open_password_manager_settings_page();
      if (success)
        result->enable_trust_first_onboarding = input.enable_trust_first_onboarding();
      if (success)
        result->onboarding_completed = input.onboarding_completed();
      if (success)
        result->enable_skills = input.enable_skills();
      if (success)
        result->enable_get_tab_favicon_by_id = input.enable_get_tab_favicon_by_id();
      if (success)
        result->enable_process_counter_abuse_verdict = input.enable_process_counter_abuse_verdict();
      if (success && !input.ReadGeminiEnterpriseSettings(&result->gemini_enterprise_settings))
        success = false;
      if (success)
        result->enable_gmail_otp_opt_in = input.enable_gmail_otp_opt_in();
      if (success)
        result->enable_gmail_otp_confirmation = input.enable_gmail_otp_confirmation();
      if (success && !input.ReadFileUploadPolicyState(&result->file_upload_policy_state))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ScreenshotCollectionOptions::DataView, ::glic::mojom::ScreenshotCollectionOptionsPtr>::Read(
    ::glic::mojom::ScreenshotCollectionOptions::DataView input,
    ::glic::mojom::ScreenshotCollectionOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::ScreenshotCollectionOptionsPtr result(::glic::mojom::ScreenshotCollectionOptions::New());
  
      if (success)
        result->max_width = input.max_width();
      if (success)
        result->max_height = input.max_height();
      if (success && !input.ReadScreenshotImageFormat(&result->screenshot_image_format))
        success = false;
      if (success && !input.ReadScreenshotCompressionQuality(&result->screenshot_compression_quality))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::TabContextOptions::DataView, ::glic::mojom::TabContextOptionsPtr>::Read(
    ::glic::mojom::TabContextOptions::DataView input,
    ::glic::mojom::TabContextOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::TabContextOptionsPtr result(::glic::mojom::TabContextOptions::New());
  
      if (success)
        result->inner_text = input.inner_text();
      if (success)
        result->inner_text_bytes_limit = input.inner_text_bytes_limit();
      if (success)
        result->viewport_screenshot = input.viewport_screenshot();
      if (success)
        result->annotated_page_content = input.annotated_page_content();
      if (success)
        result->max_meta_tags = input.max_meta_tags();
      if (success)
        result->pdf_data = input.pdf_data();
      if (success)
        result->pdf_size_limit = input.pdf_size_limit();
      if (success)
        result->annotated_page_content_mode = input.annotated_page_content_mode();
      if (success && !input.ReadScreenshotCollectionOptions(&result->screenshot_collection_options))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::GetPinCandidatesOptions::DataView, ::glic::mojom::GetPinCandidatesOptionsPtr>::Read(
    ::glic::mojom::GetPinCandidatesOptions::DataView input,
    ::glic::mojom::GetPinCandidatesOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::GetPinCandidatesOptionsPtr result(::glic::mojom::GetPinCandidatesOptions::New());
  
      if (success)
        result->max_candidates = input.max_candidates();
      if (success && !input.ReadQuery(&result->query))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ScrollToParams::DataView, ::glic::mojom::ScrollToParamsPtr>::Read(
    ::glic::mojom::ScrollToParams::DataView input,
    ::glic::mojom::ScrollToParamsPtr* output) {
  bool success = true;
  ::glic::mojom::ScrollToParamsPtr result(::glic::mojom::ScrollToParams::New());
  
      if (success && !input.ReadSelector(&result->selector))
        success = false;
      if (success)
        result->highlight = input.highlight();
      if (success && !input.ReadDocumentId(&result->document_id))
        success = false;
      if (success && !input.ReadUrl(&result->url))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ScrollToTextSelector::DataView, ::glic::mojom::ScrollToTextSelectorPtr>::Read(
    ::glic::mojom::ScrollToTextSelector::DataView input,
    ::glic::mojom::ScrollToTextSelectorPtr* output) {
  bool success = true;
  ::glic::mojom::ScrollToTextSelectorPtr result(::glic::mojom::ScrollToTextSelector::New());
  
      if (success && !input.ReadText(&result->text))
        success = false;
      if (success) {
        result->search_range_start_node_id = input.search_range_start_node_id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ScrollToTextFragmentSelector::DataView, ::glic::mojom::ScrollToTextFragmentSelectorPtr>::Read(
    ::glic::mojom::ScrollToTextFragmentSelector::DataView input,
    ::glic::mojom::ScrollToTextFragmentSelectorPtr* output) {
  bool success = true;
  ::glic::mojom::ScrollToTextFragmentSelectorPtr result(::glic::mojom::ScrollToTextFragmentSelector::New());
  
      if (success && !input.ReadTextStart(&result->text_start))
        success = false;
      if (success && !input.ReadTextEnd(&result->text_end))
        success = false;
      if (success) {
        result->search_range_start_node_id = input.search_range_start_node_id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ScrollToNodeSelector::DataView, ::glic::mojom::ScrollToNodeSelectorPtr>::Read(
    ::glic::mojom::ScrollToNodeSelector::DataView input,
    ::glic::mojom::ScrollToNodeSelectorPtr* output) {
  bool success = true;
  ::glic::mojom::ScrollToNodeSelectorPtr result(::glic::mojom::ScrollToNodeSelector::New());
  
      if (success)
        result->node_id = input.node_id();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::SuggestionContent::DataView, ::glic::mojom::SuggestionContentPtr>::Read(
    ::glic::mojom::SuggestionContent::DataView input,
    ::glic::mojom::SuggestionContentPtr* output) {
  bool success = true;
  ::glic::mojom::SuggestionContentPtr result(::glic::mojom::SuggestionContent::New());
  
      if (success && !input.ReadSuggestion(&result->suggestion))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::SkillPreview::DataView, ::glic::mojom::SkillPreviewPtr>::Read(
    ::glic::mojom::SkillPreview::DataView input,
    ::glic::mojom::SkillPreviewPtr* output) {
  bool success = true;
  ::glic::mojom::SkillPreviewPtr result(::glic::mojom::SkillPreview::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadIcon(&result->icon))
        success = false;
      if (success && !input.ReadSource(&result->source))
        success = false;
      if (success && !input.ReadDescription(&result->description))
        success = false;
      if (success && !input.ReadCuratedBy(&result->curated_by))
        success = false;
      if (success && !input.ReadImageUrl(&result->image_url))
        success = false;
      if (success && !input.ReadCategory(&result->category))
        success = false;
      if (success && !input.ReadCreationTime(&result->creation_time))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::Skill::DataView, ::glic::mojom::SkillPtr>::Read(
    ::glic::mojom::Skill::DataView input,
    ::glic::mojom::SkillPtr* output) {
  bool success = true;
  ::glic::mojom::SkillPtr result(::glic::mojom::Skill::New());
  
      if (success && !input.ReadPreview(&result->preview))
        success = false;
      if (success && !input.ReadPrompt(&result->prompt))
        success = false;
      if (success && !input.ReadSourceSkillId(&result->source_skill_id))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::CreateSkillRequest::DataView, ::glic::mojom::CreateSkillRequestPtr>::Read(
    ::glic::mojom::CreateSkillRequest::DataView input,
    ::glic::mojom::CreateSkillRequestPtr* output) {
  bool success = true;
  ::glic::mojom::CreateSkillRequestPtr result(::glic::mojom::CreateSkillRequest::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadIcon(&result->icon))
        success = false;
      if (success && !input.ReadSource(&result->source))
        success = false;
      if (success && !input.ReadPrompt(&result->prompt))
        success = false;
      if (success && !input.ReadDescription(&result->description))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::UpdateSkillRequest::DataView, ::glic::mojom::UpdateSkillRequestPtr>::Read(
    ::glic::mojom::UpdateSkillRequest::DataView input,
    ::glic::mojom::UpdateSkillRequestPtr* output) {
  bool success = true;
  ::glic::mojom::UpdateSkillRequestPtr result(::glic::mojom::UpdateSkillRequest::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ZeroStateSuggestions::DataView, ::glic::mojom::ZeroStateSuggestionsPtr>::Read(
    ::glic::mojom::ZeroStateSuggestions::DataView input,
    ::glic::mojom::ZeroStateSuggestionsPtr* output) {
  bool success = true;
  ::glic::mojom::ZeroStateSuggestionsPtr result(::glic::mojom::ZeroStateSuggestions::New());
  
      if (success && !input.ReadSuggestions(&result->suggestions))
        success = false;
      if (success)
        result->tab_id = input.tab_id();
      if (success && !input.ReadUrl(&result->url))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ZeroStateSuggestionsV2::DataView, ::glic::mojom::ZeroStateSuggestionsV2Ptr>::Read(
    ::glic::mojom::ZeroStateSuggestionsV2::DataView input,
    ::glic::mojom::ZeroStateSuggestionsV2Ptr* output) {
  bool success = true;
  ::glic::mojom::ZeroStateSuggestionsV2Ptr result(::glic::mojom::ZeroStateSuggestionsV2::New());
  
      if (success && !input.ReadSuggestions(&result->suggestions))
        success = false;
      if (success)
        result->is_pending = input.is_pending();
      if (success && !input.ReadInvocationSource(&result->invocation_source))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ZeroStateSuggestionsOptions::DataView, ::glic::mojom::ZeroStateSuggestionsOptionsPtr>::Read(
    ::glic::mojom::ZeroStateSuggestionsOptions::DataView input,
    ::glic::mojom::ZeroStateSuggestionsOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::ZeroStateSuggestionsOptionsPtr result(::glic::mojom::ZeroStateSuggestionsOptions::New());
  
      if (success)
        result->is_first_run = input.is_first_run();
      if (success && !input.ReadSupportedTools(&result->supported_tools))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::PinCandidate::DataView, ::glic::mojom::PinCandidatePtr>::Read(
    ::glic::mojom::PinCandidate::DataView input,
    ::glic::mojom::PinCandidatePtr* output) {
  bool success = true;
  ::glic::mojom::PinCandidatePtr result(::glic::mojom::PinCandidate::New());
  
      if (success && !input.ReadTabData(&result->tab_data))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::PinTabsOptions::DataView, ::glic::mojom::PinTabsOptionsPtr>::Read(
    ::glic::mojom::PinTabsOptions::DataView input,
    ::glic::mojom::PinTabsOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::PinTabsOptionsPtr result(::glic::mojom::PinTabsOptions::New());
  
      if (success && !input.ReadPinTrigger(&result->pin_trigger))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::UnpinTabsOptions::DataView, ::glic::mojom::UnpinTabsOptionsPtr>::Read(
    ::glic::mojom::UnpinTabsOptions::DataView input,
    ::glic::mojom::UnpinTabsOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::UnpinTabsOptionsPtr result(::glic::mojom::UnpinTabsOptions::New());
  
      if (success && !input.ReadUnpinTrigger(&result->unpin_trigger))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::OpenPinnedTabPickerOptions::DataView, ::glic::mojom::OpenPinnedTabPickerOptionsPtr>::Read(
    ::glic::mojom::OpenPinnedTabPickerOptions::DataView input,
    ::glic::mojom::OpenPinnedTabPickerOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::OpenPinnedTabPickerOptionsPtr result(::glic::mojom::OpenPinnedTabPickerOptions::New());
  
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::CreateActorTabOptions::DataView, ::glic::mojom::CreateActorTabOptionsPtr>::Read(
    ::glic::mojom::CreateActorTabOptions::DataView input,
    ::glic::mojom::CreateActorTabOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::CreateActorTabOptionsPtr result(::glic::mojom::CreateActorTabOptions::New());
  
      if (success) {
        result->initiator_tab_id = input.initiator_tab_id();
      }
      if (success) {
        result->initiator_window_id = input.initiator_window_id();
      }
      if (success)
        result->open_in_background = input.open_in_background();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::CaptureRegionParams::DataView, ::glic::mojom::CaptureRegionParamsPtr>::Read(
    ::glic::mojom::CaptureRegionParams::DataView input,
    ::glic::mojom::CaptureRegionParamsPtr* output) {
  bool success = true;
  ::glic::mojom::CaptureRegionParamsPtr result(::glic::mojom::CaptureRegionParams::New());
  
      if (success)
        result->tab_id = input.tab_id();
      if (success && !input.ReadOptions(&result->options))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ActivateTabOptions::DataView, ::glic::mojom::ActivateTabOptionsPtr>::Read(
    ::glic::mojom::ActivateTabOptions::DataView input,
    ::glic::mojom::ActivateTabOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::ActivateTabOptionsPtr result(::glic::mojom::ActivateTabOptions::New());
  
      if (success && !input.ReadPattern(&result->pattern))
        success = false;
      if (success) {
        result->fallback_window_id = input.fallback_window_id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::CreateTabOptions::DataView, ::glic::mojom::CreateTabOptionsPtr>::Read(
    ::glic::mojom::CreateTabOptions::DataView input,
    ::glic::mojom::CreateTabOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::CreateTabOptionsPtr result(::glic::mojom::CreateTabOptions::New());
  
      if (success)
        result->open_in_background = input.open_in_background();
      if (success) {
        result->window_id = input.window_id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ConversationInfo::DataView, ::glic::mojom::ConversationInfoPtr>::Read(
    ::glic::mojom::ConversationInfo::DataView input,
    ::glic::mojom::ConversationInfoPtr* output) {
  bool success = true;
  ::glic::mojom::ConversationInfoPtr result(::glic::mojom::ConversationInfo::New());
  
      if (success && !input.ReadConversationId(&result->conversation_id))
        success = false;
      if (success && !input.ReadConversationTitle(&result->conversation_title))
        success = false;
      if (success && !input.ReadClientData(&result->client_data))
        success = false;
      if (success && !input.ReadTurnId(&result->turn_id))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::PanelOpeningData::DataView, ::glic::mojom::PanelOpeningDataPtr>::Read(
    ::glic::mojom::PanelOpeningData::DataView input,
    ::glic::mojom::PanelOpeningDataPtr* output) {
  bool success = true;
  ::glic::mojom::PanelOpeningDataPtr result(::glic::mojom::PanelOpeningData::New());
  
      if (success && !input.ReadPanelState(&result->panel_state))
        success = false;
      if (success && !input.ReadInvocationSource(&result->invocation_source))
        success = false;
      if (success && !input.ReadPromptSuggestion(&result->prompt_suggestion))
        success = false;
      if (success)
        result->auto_send = input.auto_send();
      if (success && !input.ReadSkillToInvoke(&result->skill_to_invoke))
        success = false;
      if (success && !input.ReadRecentlyActiveConversations(&result->recently_active_conversations))
        success = false;
      if (success && !input.ReadConversationInfo(&result->conversation_info))
        success = false;
      if (success && !input.ReadFreOverride(&result->fre_override))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::PanelState::DataView, ::glic::mojom::PanelStatePtr>::Read(
    ::glic::mojom::PanelState::DataView input,
    ::glic::mojom::PanelStatePtr* output) {
  bool success = true;
  ::glic::mojom::PanelStatePtr result(::glic::mojom::PanelState::New());
  
      if (success && !input.ReadKind(&result->kind))
        success = false;
      if (success) {
        result->window_id = input.window_id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::SkillsPayload::DataView, ::glic::mojom::SkillsPayloadPtr>::Read(
    ::glic::mojom::SkillsPayload::DataView input,
    ::glic::mojom::SkillsPayloadPtr* output) {
  bool success = true;
  ::glic::mojom::SkillsPayloadPtr result(::glic::mojom::SkillsPayload::New());
  
      if (success && !input.ReadSkillId(&result->skill_id))
        success = false;
      if (success && !input.ReadSkillName(&result->skill_name))
        success = false;
      if (success && !input.ReadSkillIcon(&result->skill_icon))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::UniversalCartPayload::DataView, ::glic::mojom::UniversalCartPayloadPtr>::Read(
    ::glic::mojom::UniversalCartPayload::DataView input,
    ::glic::mojom::UniversalCartPayloadPtr* output) {
  bool success = true;
  ::glic::mojom::UniversalCartPayloadPtr result(::glic::mojom::UniversalCartPayload::New());
  
      if (success && !input.ReadSerializedMetadata(&result->serialized_metadata))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::InvokeOptions::DataView, ::glic::mojom::InvokeOptionsPtr>::Read(
    ::glic::mojom::InvokeOptions::DataView input,
    ::glic::mojom::InvokeOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::InvokeOptionsPtr result(::glic::mojom::InvokeOptions::New());
  
      if (success && !input.ReadInvocationSource(&result->invocation_source))
        success = false;
      if (success && !input.ReadPrompts(&result->prompts))
        success = false;
      if (success && !input.ReadContext(&result->context))
        success = false;
      if (success)
        result->auto_submit = input.auto_submit();
      if (success && !input.ReadFeatureMode(&result->feature_mode))
        success = false;
      if (success && !input.ReadActuationTarget(&result->actuation_target))
        success = false;
      if (success)
        result->disable_zero_state_suggestions = input.disable_zero_state_suggestions();
      if (success && !input.ReadSkillId(&result->skill_id))
        success = false;
      if (success && !input.ReadZssConfig(&result->zss_config))
        success = false;
      if (success && !input.ReadPayload(&result->payload))
        success = false;
      if (success) {
        result->actuation_tab_id = input.actuation_tab_id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::OnResponseStoppedDetails::DataView, ::glic::mojom::OnResponseStoppedDetailsPtr>::Read(
    ::glic::mojom::OnResponseStoppedDetails::DataView input,
    ::glic::mojom::OnResponseStoppedDetailsPtr* output) {
  bool success = true;
  ::glic::mojom::OnResponseStoppedDetailsPtr result(::glic::mojom::OnResponseStoppedDetails::New());
  
      if (success && !input.ReadCause(&result->cause))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::OpenPanelInfo::DataView, ::glic::mojom::OpenPanelInfoPtr>::Read(
    ::glic::mojom::OpenPanelInfo::DataView input,
    ::glic::mojom::OpenPanelInfoPtr* output) {
  bool success = true;
  ::glic::mojom::OpenPanelInfoPtr result(::glic::mojom::OpenPanelInfo::New());
  
      if (success && !input.ReadWebClientMode(&result->web_client_mode))
        success = false;
      if (success && !input.ReadPanelSize(&result->panelSize))
        success = false;
      if (success && !input.ReadResizeDuration(&result->resizeDuration))
        success = false;
      if (success)
        result->can_user_resize = input.can_user_resize();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ContextData::DataView, ::glic::mojom::ContextDataPtr>::Read(
    ::glic::mojom::ContextData::DataView input,
    ::glic::mojom::ContextDataPtr* output) {
  bool success = true;
  ::glic::mojom::ContextDataPtr result(::glic::mojom::ContextData::New());
  
      if (success && !input.ReadMimeType(&result->mime_type))
        success = false;
      if (success && !input.ReadData(&result->data))
        success = false;
      if (success && !input.ReadFilename(&result->filename))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ParentConversationMetadata::DataView, ::glic::mojom::ParentConversationMetadataPtr>::Read(
    ::glic::mojom::ParentConversationMetadata::DataView input,
    ::glic::mojom::ParentConversationMetadataPtr* output) {
  bool success = true;
  ::glic::mojom::ParentConversationMetadataPtr result(::glic::mojom::ParentConversationMetadata::New());
  
      if (success && !input.ReadConversationId(&result->conversation_id))
        success = false;
      if (success && !input.ReadConversationTitle(&result->conversation_title))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::AdditionalContext::DataView, ::glic::mojom::AdditionalContextPtr>::Read(
    ::glic::mojom::AdditionalContext::DataView input,
    ::glic::mojom::AdditionalContextPtr* output) {
  bool success = true;
  ::glic::mojom::AdditionalContextPtr result(::glic::mojom::AdditionalContext::New());
  
      if (success && !input.ReadSource(&result->source))
        success = false;
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success) {
        result->tab_id = input.tab_id();
      }
      if (success && !input.ReadOrigin(&result->origin))
        success = false;
      if (success && !input.ReadFrameUrl(&result->frameUrl))
        success = false;
      if (success && !input.ReadParts(&result->parts))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ExperimentalTriggeringUpdate::DataView, ::glic::mojom::ExperimentalTriggeringUpdatePtr>::Read(
    ::glic::mojom::ExperimentalTriggeringUpdate::DataView input,
    ::glic::mojom::ExperimentalTriggeringUpdatePtr* output) {
  bool success = true;
  ::glic::mojom::ExperimentalTriggeringUpdatePtr result(::glic::mojom::ExperimentalTriggeringUpdate::New());
  
      if (success && !input.ReadType(&result->type))
        success = false;
      if (success && !input.ReadData(&result->data))
        success = false;
      if (success && !input.ReadMetadata(&result->metadata))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::TabContextResult::DataView, ::glic::mojom::TabContextResultPtr>::Read(
    ::glic::mojom::TabContextResult::DataView input,
    ::glic::mojom::TabContextResultPtr* output) {
  bool success = true;
  ::glic::mojom::TabContextResultPtr result(::glic::mojom::TabContextResult::New());
  
      if (success && !input.ReadTabData(&result->tab_data))
        success = false;
      if (success && !input.ReadWebPageData(&result->web_page_data))
        success = false;
      if (success && !input.ReadViewportScreenshot(&result->viewport_screenshot))
        success = false;
      if (success && !input.ReadScreenshotInfo(&result->screenshot_info))
        success = false;
      if (success && !input.ReadPdfDocumentData(&result->pdf_document_data))
        success = false;
      if (success && !input.ReadAnnotatedPageData(&result->annotated_page_data))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::WebPageData::DataView, ::glic::mojom::WebPageDataPtr>::Read(
    ::glic::mojom::WebPageData::DataView input,
    ::glic::mojom::WebPageDataPtr* output) {
  bool success = true;
  ::glic::mojom::WebPageDataPtr result(::glic::mojom::WebPageData::New());
  
      if (success && !input.ReadMainDocument(&result->main_document))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::DocumentData::DataView, ::glic::mojom::DocumentDataPtr>::Read(
    ::glic::mojom::DocumentData::DataView input,
    ::glic::mojom::DocumentDataPtr* output) {
  bool success = true;
  ::glic::mojom::DocumentDataPtr result(::glic::mojom::DocumentData::New());
  
      if (success && !input.ReadOrigin(&result->origin))
        success = false;
      if (success && !input.ReadInnerText(&result->inner_text))
        success = false;
      if (success)
        result->inner_text_truncated = input.inner_text_truncated();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::PdfDocumentData::DataView, ::glic::mojom::PdfDocumentDataPtr>::Read(
    ::glic::mojom::PdfDocumentData::DataView input,
    ::glic::mojom::PdfDocumentDataPtr* output) {
  bool success = true;
  ::glic::mojom::PdfDocumentDataPtr result(::glic::mojom::PdfDocumentData::New());
  
      if (success && !input.ReadOrigin(&result->origin))
        success = false;
      if (success && !input.ReadPdfData(&result->pdf_data))
        success = false;
      if (success)
        result->pdf_size_limit_exceeded = input.pdf_size_limit_exceeded();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::TabData::DataView, ::glic::mojom::TabDataPtr>::Read(
    ::glic::mojom::TabData::DataView input,
    ::glic::mojom::TabDataPtr* output) {
  bool success = true;
  ::glic::mojom::TabDataPtr result(::glic::mojom::TabData::New());
  
      if (success)
        result->tab_id = input.tab_id();
      if (success)
        result->window_id = input.window_id();
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadTitle(&result->title))
        success = false;
      if (success && !input.ReadFavicon(&result->favicon))
        success = false;
      if (success && !input.ReadFaviconUrl(&result->favicon_url))
        success = false;
      if (success && !input.ReadDocumentMimeType(&result->document_mime_type))
        success = false;
      if (success) {
        result->is_observable = input.is_observable();
      }
      if (success) {
        result->is_media_active = input.is_media_active();
      }
      if (success) {
        result->is_tab_content_captured = input.is_tab_content_captured();
      }
      if (success) {
        result->is_active_in_window = input.is_active_in_window();
      }
      if (success) {
        result->is_window_active = input.is_window_active();
      }
      if (success && !input.ReadLightweightPageFeatures(&result->lightweight_page_features))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::NoFocusedTabData::DataView, ::glic::mojom::NoFocusedTabDataPtr>::Read(
    ::glic::mojom::NoFocusedTabData::DataView input,
    ::glic::mojom::NoFocusedTabDataPtr* output) {
  bool success = true;
  ::glic::mojom::NoFocusedTabDataPtr result(::glic::mojom::NoFocusedTabData::New());
  
      if (success && !input.ReadActiveTabData(&result->active_tab_data))
        success = false;
      if (success && !input.ReadNoFocusReason(&result->no_focus_reason))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::AnnotatedPageData::DataView, ::glic::mojom::AnnotatedPageDataPtr>::Read(
    ::glic::mojom::AnnotatedPageData::DataView input,
    ::glic::mojom::AnnotatedPageDataPtr* output) {
  bool success = true;
  ::glic::mojom::AnnotatedPageDataPtr result(::glic::mojom::AnnotatedPageData::New());
  
      if (success && !input.ReadAnnotatedPageContent(&result->annotated_page_content))
        success = false;
      if (success && !input.ReadMetadata(&result->metadata))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ImageOriginAnnotations::DataView, ::glic::mojom::ImageOriginAnnotationsPtr>::Read(
    ::glic::mojom::ImageOriginAnnotations::DataView input,
    ::glic::mojom::ImageOriginAnnotationsPtr* output) {
  bool success = true;
  ::glic::mojom::ImageOriginAnnotationsPtr result(::glic::mojom::ImageOriginAnnotations::New());
  
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::Journal::DataView, ::glic::mojom::JournalPtr>::Read(
    ::glic::mojom::Journal::DataView input,
    ::glic::mojom::JournalPtr* output) {
  bool success = true;
  ::glic::mojom::JournalPtr result(::glic::mojom::Journal::New());
  
      if (success && !input.ReadData(&result->data))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::PendingCapturedRegion::DataView, ::glic::mojom::PendingCapturedRegionPtr>::Read(
    ::glic::mojom::PendingCapturedRegion::DataView input,
    ::glic::mojom::PendingCapturedRegionPtr* output) {
  bool success = true;
  ::glic::mojom::PendingCapturedRegionPtr result(::glic::mojom::PendingCapturedRegion::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadRegion(&result->region))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::CaptureRegionResult::DataView, ::glic::mojom::CaptureRegionResultPtr>::Read(
    ::glic::mojom::CaptureRegionResult::DataView input,
    ::glic::mojom::CaptureRegionResultPtr* output) {
  bool success = true;
  ::glic::mojom::CaptureRegionResultPtr result(::glic::mojom::CaptureRegionResult::New());
  
      if (success)
        result->tab_id = input.tab_id();
      if (success && !input.ReadRegion(&result->region))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::Screenshot::DataView, ::glic::mojom::ScreenshotPtr>::Read(
    ::glic::mojom::Screenshot::DataView input,
    ::glic::mojom::ScreenshotPtr* output) {
  bool success = true;
  ::glic::mojom::ScreenshotPtr result(::glic::mojom::Screenshot::New());
  
      if (success)
        result->width_pixels = input.width_pixels();
      if (success)
        result->height_pixels = input.height_pixels();
      if (success && !input.ReadData(&result->data))
        success = false;
      if (success && !input.ReadMimeType(&result->mime_type))
        success = false;
      if (success && !input.ReadOriginAnnotations(&result->origin_annotations))
        success = false;
      if (success && !input.ReadEncryptionScheme(&result->encryption_scheme))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ImageInfo::DataView, ::glic::mojom::ImageInfoPtr>::Read(
    ::glic::mojom::ImageInfo::DataView input,
    ::glic::mojom::ImageInfoPtr* output) {
  bool success = true;
  ::glic::mojom::ImageInfoPtr result(::glic::mojom::ImageInfo::New());
  
      if (success && !input.ReadCaption(&result->caption))
        success = false;
      if (success && !input.ReadSourceOrigin(&result->source_origin))
        success = false;
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadMimeType(&result->mime_type))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ImageBytesResult::DataView, ::glic::mojom::ImageBytesResultPtr>::Read(
    ::glic::mojom::ImageBytesResult::DataView input,
    ::glic::mojom::ImageBytesResultPtr* output) {
  bool success = true;
  ::glic::mojom::ImageBytesResultPtr result(::glic::mojom::ImageBytesResult::New());
  
      if (success && !input.ReadBytes(&result->bytes))
        success = false;
      if (success && !input.ReadImageInfo(&result->image_info))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::OpenSettingsOptions::DataView, ::glic::mojom::OpenSettingsOptionsPtr>::Read(
    ::glic::mojom::OpenSettingsOptions::DataView input,
    ::glic::mojom::OpenSettingsOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::OpenSettingsOptionsPtr result(::glic::mojom::OpenSettingsOptions::New());
  
      if (success && !input.ReadHighlightField(&result->highlightField))
        success = false;
  *output = std::move(result);
  return success;
}

// static
bool UnionTraits<::glic::mojom::InvokeConversationSelection::DataView, ::glic::mojom::InvokeConversationSelectionPtr>::Read(
    ::glic::mojom::InvokeConversationSelection::DataView input,
    ::glic::mojom::InvokeConversationSelectionPtr* output) {
  using UnionType = ::glic::mojom::InvokeConversationSelection;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kDefaultConversation: {
      ::glic::mojom::DefaultConversationPtr result_default_conversation{};
      if (!input.ReadDefaultConversation(&result_default_conversation))
        return false;

      *output = UnionType::NewDefaultConversation(
          std::move(result_default_conversation));
      break;
    }
    case Tag::kNewConversation: {
      ::glic::mojom::NewConversationPtr result_new_conversation{};
      if (!input.ReadNewConversation(&result_new_conversation))
        return false;

      *output = UnionType::NewNewConversation(
          std::move(result_new_conversation));
      break;
    }
    case Tag::kConversationId: {
      std::string result_conversation_id{};
      if (!input.ReadConversationId(&result_conversation_id))
        return false;

      *output = UnionType::NewConversationId(
          std::move(result_conversation_id));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::InvokeTargetSurface::DataView, ::glic::mojom::InvokeTargetSurfacePtr>::Read(
    ::glic::mojom::InvokeTargetSurface::DataView input,
    ::glic::mojom::InvokeTargetSurfacePtr* output) {
  using UnionType = ::glic::mojom::InvokeTargetSurface;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kDefaultSurface: {
      ::glic::mojom::DefaultSurfaceMojoPtr result_default_surface{};
      if (!input.ReadDefaultSurface(&result_default_surface))
        return false;

      *output = UnionType::NewDefaultSurface(
          std::move(result_default_surface));
      break;
    }
    case Tag::kNewTab: {
      ::glic::mojom::NewTabMojoPtr result_new_tab{};
      if (!input.ReadNewTab(&result_new_tab))
        return false;

      *output = UnionType::NewNewTab(
          std::move(result_new_tab));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::GetContextResult::DataView, ::glic::mojom::GetContextResultPtr>::Read(
    ::glic::mojom::GetContextResult::DataView input,
    ::glic::mojom::GetContextResultPtr* output) {
  using UnionType = ::glic::mojom::GetContextResult;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kErrorReason: {
      std::string result_error_reason{};
      if (!input.ReadErrorReason(&result_error_reason))
        return false;

      *output = UnionType::NewErrorReason(
          std::move(result_error_reason));
      break;
    }
    case Tag::kTabContext: {
      ::glic::mojom::TabContextResultPtr result_tab_context{};
      if (!input.ReadTabContext(&result_tab_context))
        return false;

      *output = UnionType::NewTabContext(
          std::move(result_tab_context));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::CaptureScreenshotResult::DataView, ::glic::mojom::CaptureScreenshotResultPtr>::Read(
    ::glic::mojom::CaptureScreenshotResult::DataView input,
    ::glic::mojom::CaptureScreenshotResultPtr* output) {
  using UnionType = ::glic::mojom::CaptureScreenshotResult;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kErrorReason: {
      ::glic::mojom::CaptureScreenshotErrorReason result_error_reason;
      if (!input.ReadErrorReason(&result_error_reason))
        return false;

      *output = UnionType::NewErrorReason(result_error_reason);
      break;
    }
    case Tag::kScreenshot: {
      ::glic::mojom::ScreenshotPtr result_screenshot{};
      if (!input.ReadScreenshot(&result_screenshot))
        return false;

      *output = UnionType::NewScreenshot(
          std::move(result_screenshot));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::ScrollToSelector::DataView, ::glic::mojom::ScrollToSelectorPtr>::Read(
    ::glic::mojom::ScrollToSelector::DataView input,
    ::glic::mojom::ScrollToSelectorPtr* output) {
  using UnionType = ::glic::mojom::ScrollToSelector;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kExactText: {
      ::glic::mojom::ScrollToTextSelectorPtr result_exact_text{};
      if (!input.ReadExactText(&result_exact_text))
        return false;

      *output = UnionType::NewExactText(
          std::move(result_exact_text));
      break;
    }
    case Tag::kTextFragment: {
      ::glic::mojom::ScrollToTextFragmentSelectorPtr result_text_fragment{};
      if (!input.ReadTextFragment(&result_text_fragment))
        return false;

      *output = UnionType::NewTextFragment(
          std::move(result_text_fragment));
      break;
    }
    case Tag::kNode: {
      ::glic::mojom::ScrollToNodeSelectorPtr result_node{};
      if (!input.ReadNode(&result_node))
        return false;

      *output = UnionType::NewNode(
          std::move(result_node));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::InvocationPayload::DataView, ::glic::mojom::InvocationPayloadPtr>::Read(
    ::glic::mojom::InvocationPayload::DataView input,
    ::glic::mojom::InvocationPayloadPtr* output) {
  using UnionType = ::glic::mojom::InvocationPayload;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kUniversalCart: {
      ::glic::mojom::UniversalCartPayloadPtr result_universal_cart{};
      if (!input.ReadUniversalCart(&result_universal_cart))
        return false;

      *output = UnionType::NewUniversalCart(
          std::move(result_universal_cart));
      break;
    }
    case Tag::kSkillsPayload: {
      ::glic::mojom::SkillsPayloadPtr result_skills_payload{};
      if (!input.ReadSkillsPayload(&result_skills_payload))
        return false;

      *output = UnionType::NewSkillsPayload(
          std::move(result_skills_payload));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::AdditionalContextPart::DataView, ::glic::mojom::AdditionalContextPartPtr>::Read(
    ::glic::mojom::AdditionalContextPart::DataView input,
    ::glic::mojom::AdditionalContextPartPtr* output) {
  using UnionType = ::glic::mojom::AdditionalContextPart;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kData: {
      ::glic::mojom::ContextDataPtr result_data{};
      if (!input.ReadData(&result_data))
        return false;

      *output = UnionType::NewData(
          std::move(result_data));
      break;
    }
    case Tag::kScreenshot: {
      ::glic::mojom::ScreenshotPtr result_screenshot{};
      if (!input.ReadScreenshot(&result_screenshot))
        return false;

      *output = UnionType::NewScreenshot(
          std::move(result_screenshot));
      break;
    }
    case Tag::kWebPageData: {
      ::glic::mojom::WebPageDataPtr result_web_page_data{};
      if (!input.ReadWebPageData(&result_web_page_data))
        return false;

      *output = UnionType::NewWebPageData(
          std::move(result_web_page_data));
      break;
    }
    case Tag::kAnnotatedPageData: {
      ::glic::mojom::AnnotatedPageDataPtr result_annotated_page_data{};
      if (!input.ReadAnnotatedPageData(&result_annotated_page_data))
        return false;

      *output = UnionType::NewAnnotatedPageData(
          std::move(result_annotated_page_data));
      break;
    }
    case Tag::kPdfDocumentData: {
      ::glic::mojom::PdfDocumentDataPtr result_pdf_document_data{};
      if (!input.ReadPdfDocumentData(&result_pdf_document_data))
        return false;

      *output = UnionType::NewPdfDocumentData(
          std::move(result_pdf_document_data));
      break;
    }
    case Tag::kTabContext: {
      ::glic::mojom::TabContextResultPtr result_tab_context{};
      if (!input.ReadTabContext(&result_tab_context))
        return false;

      *output = UnionType::NewTabContext(
          std::move(result_tab_context));
      break;
    }
    case Tag::kRegion: {
      ::glic::mojom::CapturedRegionPtr result_region{};
      if (!input.ReadRegion(&result_region))
        return false;

      *output = UnionType::NewRegion(
          std::move(result_region));
      break;
    }
    case Tag::kPendingRegion: {
      ::glic::mojom::PendingCapturedRegionPtr result_pending_region{};
      if (!input.ReadPendingRegion(&result_pending_region))
        return false;

      *output = UnionType::NewPendingRegion(
          std::move(result_pending_region));
      break;
    }
    case Tag::kParentConversationMetadata: {
      ::glic::mojom::ParentConversationMetadataPtr result_parent_conversation_metadata{};
      if (!input.ReadParentConversationMetadata(&result_parent_conversation_metadata))
        return false;

      *output = UnionType::NewParentConversationMetadata(
          std::move(result_parent_conversation_metadata));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::FocusedTabData::DataView, ::glic::mojom::FocusedTabDataPtr>::Read(
    ::glic::mojom::FocusedTabData::DataView input,
    ::glic::mojom::FocusedTabDataPtr* output) {
  using UnionType = ::glic::mojom::FocusedTabData;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kFocusedTab: {
      ::glic::mojom::TabDataPtr result_focused_tab{};
      if (!input.ReadFocusedTab(&result_focused_tab))
        return false;

      *output = UnionType::NewFocusedTab(
          std::move(result_focused_tab));
      break;
    }
    case Tag::kNoFocusedTabData: {
      ::glic::mojom::NoFocusedTabDataPtr result_no_focused_tab_data{};
      if (!input.ReadNoFocusedTabData(&result_no_focused_tab_data))
        return false;

      *output = UnionType::NewNoFocusedTabData(
          std::move(result_no_focused_tab_data));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::CapturedRegion::DataView, ::glic::mojom::CapturedRegionPtr>::Read(
    ::glic::mojom::CapturedRegion::DataView input,
    ::glic::mojom::CapturedRegionPtr* output) {
  using UnionType = ::glic::mojom::CapturedRegion;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kRect: {
      ::gfx::Rect result_rect{};
      if (!input.ReadRect(&result_rect))
        return false;

      *output = UnionType::NewRect(
          std::move(result_rect));
      break;
    }
    case Tag::kPolyline: {
      std::vector<::gfx::Point> result_polyline{};
      if (!input.ReadPolyline(&result_polyline))
        return false;

      *output = UnionType::NewPolyline(
          std::move(result_polyline));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::GetImageBytesResult::DataView, ::glic::mojom::GetImageBytesResultPtr>::Read(
    ::glic::mojom::GetImageBytesResult::DataView input,
    ::glic::mojom::GetImageBytesResultPtr* output) {
  using UnionType = ::glic::mojom::GetImageBytesResult;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kImageBytes: {
      ::glic::mojom::ImageBytesResultPtr result_image_bytes{};
      if (!input.ReadImageBytes(&result_image_bytes))
        return false;

      *output = UnionType::NewImageBytes(
          std::move(result_image_bytes));
      break;
    }
    case Tag::kErrorReason: {
      std::string result_error_reason{};
      if (!input.ReadErrorReason(&result_error_reason))
        return false;

      *output = UnionType::NewErrorReason(
          std::move(result_error_reason));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::DataView, ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr>::Read(
    ::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::DataView input,
    ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr* output) {
  using UnionType = ::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      *output = UnionType::NewSuccess(input.success());
      break;
    }
    case Tag::kFailure: {
      ::glic::mojom::CreateTaskErrorReason result_failure;
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(result_failure);
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::DataView, ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr>::Read(
    ::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::DataView input,
    ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr* output) {
  using UnionType = ::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::mojo_base::ProtoWrapper result_success{mojo::internal::DefaultConstructTag()};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::glic::mojom::PerformActionsErrorReason result_failure;
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(result_failure);
      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 glic::mojom {


void PinCandidatesObserverInterceptorForTesting::OnPinCandidatesChanged(std::vector<PinCandidatePtr> candidates) {
  GetForwardingInterface()->OnPinCandidatesChanged(
    std::move(candidates)
    );
}
PinCandidatesObserverAsyncWaiter::PinCandidatesObserverAsyncWaiter(
    PinCandidatesObserver* proxy) : proxy_(proxy) {}

PinCandidatesObserverAsyncWaiter::~PinCandidatesObserverAsyncWaiter() = default;





void ActorClientInterceptorForTesting::RequestToShowCredentialSelectionDialog(::actor::webui::mojom::SelectCredentialDialogRequestPtr request, RequestToShowCredentialSelectionDialogCallback callback) {
  GetForwardingInterface()->RequestToShowCredentialSelectionDialog(
    std::move(request)
    , std::move(callback));
}
void ActorClientInterceptorForTesting::RequestToShowAutofillSuggestionsDialog(::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr request, RequestToShowAutofillSuggestionsDialogCallback callback) {
  GetForwardingInterface()->RequestToShowAutofillSuggestionsDialog(
    std::move(request)
    , std::move(callback));
}
void ActorClientInterceptorForTesting::RequestToShowUserConfirmationDialog(::actor::webui::mojom::UserConfirmationDialogRequestPtr request, RequestToShowUserConfirmationDialogCallback callback) {
  GetForwardingInterface()->RequestToShowUserConfirmationDialog(
    std::move(request)
    , std::move(callback));
}
void ActorClientInterceptorForTesting::RequestToConfirmNavigation(::actor::webui::mojom::NavigationConfirmationRequestPtr request, RequestToConfirmNavigationCallback callback) {
  GetForwardingInterface()->RequestToConfirmNavigation(
    std::move(request)
    , std::move(callback));
}
void ActorClientInterceptorForTesting::NotifyActorTaskStateChanged(int32_t task_id, ActorTaskState state) {
  GetForwardingInterface()->NotifyActorTaskStateChanged(
    std::move(task_id)
    , 
    std::move(state)
    );
}
void ActorClientInterceptorForTesting::RequestToShowGmailOtpOptInDialog(::actor::webui::mojom::GmailOtpOptInRequestPtr request, RequestToShowGmailOtpOptInDialogCallback callback) {
  GetForwardingInterface()->RequestToShowGmailOtpOptInDialog(
    std::move(request)
    , std::move(callback));
}
void ActorClientInterceptorForTesting::RequestToShowGmailOtpConfirmationDialog(::actor::webui::mojom::GmailOtpConfirmationRequestPtr request, RequestToShowGmailOtpConfirmationDialogCallback callback) {
  GetForwardingInterface()->RequestToShowGmailOtpConfirmationDialog(
    std::move(request)
    , std::move(callback));
}
ActorClientAsyncWaiter::ActorClientAsyncWaiter(
    ActorClient* proxy) : proxy_(proxy) {}

ActorClientAsyncWaiter::~ActorClientAsyncWaiter() = default;


void ActorClientAsyncWaiter::RequestToShowCredentialSelectionDialog(
    ::actor::webui::mojom::SelectCredentialDialogRequestPtr request, ::actor::webui::mojom::SelectCredentialDialogResponsePtr* out_response) {
  base::RunLoop loop;
  proxy_->RequestToShowCredentialSelectionDialog(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::actor::webui::mojom::SelectCredentialDialogResponsePtr* out_response
,
             ::actor::webui::mojom::SelectCredentialDialogResponsePtr response) {*out_response = std::move(response);
            loop->Quit();
          },
          &loop,
          out_response));
  loop.Run();
}

::actor::webui::mojom::SelectCredentialDialogResponsePtr ActorClientAsyncWaiter::RequestToShowCredentialSelectionDialog(
    ::actor::webui::mojom::SelectCredentialDialogRequestPtr request) {
  ::actor::webui::mojom::SelectCredentialDialogResponsePtr async_wait_result;
  RequestToShowCredentialSelectionDialog(std::move(request),&async_wait_result);
  return async_wait_result;
}

void ActorClientAsyncWaiter::RequestToShowAutofillSuggestionsDialog(
    ::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr request, ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr* out_response) {
  base::RunLoop loop;
  proxy_->RequestToShowAutofillSuggestionsDialog(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr* out_response
,
             ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr response) {*out_response = std::move(response);
            loop->Quit();
          },
          &loop,
          out_response));
  loop.Run();
}

::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr ActorClientAsyncWaiter::RequestToShowAutofillSuggestionsDialog(
    ::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr request) {
  ::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr async_wait_result;
  RequestToShowAutofillSuggestionsDialog(std::move(request),&async_wait_result);
  return async_wait_result;
}

void ActorClientAsyncWaiter::RequestToShowUserConfirmationDialog(
    ::actor::webui::mojom::UserConfirmationDialogRequestPtr request, ::actor::webui::mojom::UserConfirmationDialogResponsePtr* out_response) {
  base::RunLoop loop;
  proxy_->RequestToShowUserConfirmationDialog(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::actor::webui::mojom::UserConfirmationDialogResponsePtr* out_response
,
             ::actor::webui::mojom::UserConfirmationDialogResponsePtr response) {*out_response = std::move(response);
            loop->Quit();
          },
          &loop,
          out_response));
  loop.Run();
}

::actor::webui::mojom::UserConfirmationDialogResponsePtr ActorClientAsyncWaiter::RequestToShowUserConfirmationDialog(
    ::actor::webui::mojom::UserConfirmationDialogRequestPtr request) {
  ::actor::webui::mojom::UserConfirmationDialogResponsePtr async_wait_result;
  RequestToShowUserConfirmationDialog(std::move(request),&async_wait_result);
  return async_wait_result;
}

void ActorClientAsyncWaiter::RequestToConfirmNavigation(
    ::actor::webui::mojom::NavigationConfirmationRequestPtr request, ::actor::webui::mojom::NavigationConfirmationResponsePtr* out_response) {
  base::RunLoop loop;
  proxy_->RequestToConfirmNavigation(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::actor::webui::mojom::NavigationConfirmationResponsePtr* out_response
,
             ::actor::webui::mojom::NavigationConfirmationResponsePtr response) {*out_response = std::move(response);
            loop->Quit();
          },
          &loop,
          out_response));
  loop.Run();
}

::actor::webui::mojom::NavigationConfirmationResponsePtr ActorClientAsyncWaiter::RequestToConfirmNavigation(
    ::actor::webui::mojom::NavigationConfirmationRequestPtr request) {
  ::actor::webui::mojom::NavigationConfirmationResponsePtr async_wait_result;
  RequestToConfirmNavigation(std::move(request),&async_wait_result);
  return async_wait_result;
}

void ActorClientAsyncWaiter::RequestToShowGmailOtpOptInDialog(
    ::actor::webui::mojom::GmailOtpOptInRequestPtr request, ::actor::webui::mojom::GmailOtpOptInResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->RequestToShowGmailOtpOptInDialog(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::actor::webui::mojom::GmailOtpOptInResultPtr* out_result
,
             ::actor::webui::mojom::GmailOtpOptInResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

::actor::webui::mojom::GmailOtpOptInResultPtr ActorClientAsyncWaiter::RequestToShowGmailOtpOptInDialog(
    ::actor::webui::mojom::GmailOtpOptInRequestPtr request) {
  ::actor::webui::mojom::GmailOtpOptInResultPtr async_wait_result;
  RequestToShowGmailOtpOptInDialog(std::move(request),&async_wait_result);
  return async_wait_result;
}

void ActorClientAsyncWaiter::RequestToShowGmailOtpConfirmationDialog(
    ::actor::webui::mojom::GmailOtpConfirmationRequestPtr request, ::actor::webui::mojom::GmailOtpConfirmationResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->RequestToShowGmailOtpConfirmationDialog(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::actor::webui::mojom::GmailOtpConfirmationResultPtr* out_result
,
             ::actor::webui::mojom::GmailOtpConfirmationResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

::actor::webui::mojom::GmailOtpConfirmationResultPtr ActorClientAsyncWaiter::RequestToShowGmailOtpConfirmationDialog(
    ::actor::webui::mojom::GmailOtpConfirmationRequestPtr request) {
  ::actor::webui::mojom::GmailOtpConfirmationResultPtr async_wait_result;
  RequestToShowGmailOtpConfirmationDialog(std::move(request),&async_wait_result);
  return async_wait_result;
}




void ActorHandlerInterceptorForTesting::AutofillSuggestionDialogOnFormPresented(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsPtr params) {
  GetForwardingInterface()->AutofillSuggestionDialogOnFormPresented(
    std::move(task_id)
    , 
    std::move(params)
    );
}
void ActorHandlerInterceptorForTesting::AutofillSuggestionDialogOnFormPreviewChanged(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsPtr params) {
  GetForwardingInterface()->AutofillSuggestionDialogOnFormPreviewChanged(
    std::move(task_id)
    , 
    std::move(params)
    );
}
void ActorHandlerInterceptorForTesting::AutofillSuggestionDialogOnFormConfirmed(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsPtr params) {
  GetForwardingInterface()->AutofillSuggestionDialogOnFormConfirmed(
    std::move(task_id)
    , 
    std::move(params)
    );
}
void ActorHandlerInterceptorForTesting::GetContextForActorFromTab(int32_t tab_id, TabContextOptionsPtr options, GetContextForActorFromTabCallback callback) {
  GetForwardingInterface()->GetContextForActorFromTab(
    std::move(tab_id)
    , 
    std::move(options)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::CreateTask(::actor::webui::mojom::TaskOptionsPtr task_options, CreateTaskCallback callback) {
  GetForwardingInterface()->CreateTask(
    std::move(task_options)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::PerformActions(const std::vector<uint8_t>& actions_proto, PerformActionsCallback callback) {
  GetForwardingInterface()->PerformActions(
    std::move(actions_proto)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::CancelActions(int32_t task_id, CancelActionsCallback callback) {
  GetForwardingInterface()->CancelActions(
    std::move(task_id)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::StopActorTask(int32_t task_id, ActorTaskStopReason stop_reason) {
  GetForwardingInterface()->StopActorTask(
    std::move(task_id)
    , 
    std::move(stop_reason)
    );
}
void ActorHandlerInterceptorForTesting::PauseActorTask(int32_t task_id, ActorTaskPauseReason pause_reason, std::optional<int32_t> tab_id) {
  GetForwardingInterface()->PauseActorTask(
    std::move(task_id)
    , 
    std::move(pause_reason)
    , 
    std::move(tab_id)
    );
}
void ActorHandlerInterceptorForTesting::ResumeActorTask(int32_t task_id, TabContextOptionsPtr context_options, ResumeActorTaskCallback callback) {
  GetForwardingInterface()->ResumeActorTask(
    std::move(task_id)
    , 
    std::move(context_options)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::InterruptActorTask(int32_t task_id, std::optional<ActorTaskInterruptReason> interrupt_reason) {
  GetForwardingInterface()->InterruptActorTask(
    std::move(task_id)
    , 
    std::move(interrupt_reason)
    );
}
void ActorHandlerInterceptorForTesting::UninterruptActorTask(int32_t task_id) {
  GetForwardingInterface()->UninterruptActorTask(
    std::move(task_id)
    );
}
void ActorHandlerInterceptorForTesting::UpdateActorTaskStepProgress(int32_t task_id, const std::string& step_progress) {
  GetForwardingInterface()->UpdateActorTaskStepProgress(
    std::move(task_id)
    , 
    std::move(step_progress)
    );
}
void ActorHandlerInterceptorForTesting::CreateActorTab(int32_t task_id, CreateActorTabOptionsPtr options, CreateActorTabCallback callback) {
  GetForwardingInterface()->CreateActorTab(
    std::move(task_id)
    , 
    std::move(options)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::LogBeginAsyncEvent(uint64_t event_async_id, int32_t task_id, const std::string& event, const std::string& details) {
  GetForwardingInterface()->LogBeginAsyncEvent(
    std::move(event_async_id)
    , 
    std::move(task_id)
    , 
    std::move(event)
    , 
    std::move(details)
    );
}
void ActorHandlerInterceptorForTesting::LogEndAsyncEvent(uint64_t event_async_id, const std::string& details) {
  GetForwardingInterface()->LogEndAsyncEvent(
    std::move(event_async_id)
    , 
    std::move(details)
    );
}
void ActorHandlerInterceptorForTesting::LogInstantEvent(int32_t task_id, const std::string& event, const std::string& details) {
  GetForwardingInterface()->LogInstantEvent(
    std::move(task_id)
    , 
    std::move(event)
    , 
    std::move(details)
    );
}
void ActorHandlerInterceptorForTesting::JournalClear() {
  GetForwardingInterface()->JournalClear();
}
void ActorHandlerInterceptorForTesting::JournalSnapshot(bool clear_journal, JournalSnapshotCallback callback) {
  GetForwardingInterface()->JournalSnapshot(
    std::move(clear_journal)
    , std::move(callback));
}
void ActorHandlerInterceptorForTesting::JournalStart(uint64_t max_bytes, bool capture_screenshots) {
  GetForwardingInterface()->JournalStart(
    std::move(max_bytes)
    , 
    std::move(capture_screenshots)
    );
}
void ActorHandlerInterceptorForTesting::JournalStop() {
  GetForwardingInterface()->JournalStop();
}
void ActorHandlerInterceptorForTesting::JournalRecordFeedback(bool positive, const std::string& reason) {
  GetForwardingInterface()->JournalRecordFeedback(
    std::move(positive)
    , 
    std::move(reason)
    );
}
ActorHandlerAsyncWaiter::ActorHandlerAsyncWaiter(
    ActorHandler* proxy) : proxy_(proxy) {}

ActorHandlerAsyncWaiter::~ActorHandlerAsyncWaiter() = default;


void ActorHandlerAsyncWaiter::GetContextForActorFromTab(
    int32_t tab_id, TabContextOptionsPtr options, GetContextResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->GetContextForActorFromTab(
      std::move(tab_id),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             GetContextResultPtr* out_result
,
             GetContextResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

GetContextResultPtr ActorHandlerAsyncWaiter::GetContextForActorFromTab(
    int32_t tab_id, TabContextOptionsPtr options) {
  GetContextResultPtr async_wait_result;
  GetContextForActorFromTab(std::move(tab_id),std::move(options),&async_wait_result);
  return async_wait_result;
}

void ActorHandlerAsyncWaiter::CancelActions(
    int32_t task_id, CancelActionsResult* out_result) {
  base::RunLoop loop;
  proxy_->CancelActions(
      std::move(task_id),
      base::BindOnce(
          [](base::RunLoop* loop,
             CancelActionsResult* out_result
,
             CancelActionsResult result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

CancelActionsResult ActorHandlerAsyncWaiter::CancelActions(
    int32_t task_id) {
  CancelActionsResult async_wait_result;
  CancelActions(std::move(task_id),&async_wait_result);
  return async_wait_result;
}

void ActorHandlerAsyncWaiter::ResumeActorTask(
    int32_t task_id, TabContextOptionsPtr context_options, GetContextResultWithActionResultCodePtr* out_result) {
  base::RunLoop loop;
  proxy_->ResumeActorTask(
      std::move(task_id),
      std::move(context_options),
      base::BindOnce(
          [](base::RunLoop* loop,
             GetContextResultWithActionResultCodePtr* out_result
,
             GetContextResultWithActionResultCodePtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

GetContextResultWithActionResultCodePtr ActorHandlerAsyncWaiter::ResumeActorTask(
    int32_t task_id, TabContextOptionsPtr context_options) {
  GetContextResultWithActionResultCodePtr async_wait_result;
  ResumeActorTask(std::move(task_id),std::move(context_options),&async_wait_result);
  return async_wait_result;
}

void ActorHandlerAsyncWaiter::CreateActorTab(
    int32_t task_id, CreateActorTabOptionsPtr options, TabDataPtr* out_tab_data) {
  base::RunLoop loop;
  proxy_->CreateActorTab(
      std::move(task_id),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             TabDataPtr* out_tab_data
,
             TabDataPtr tab_data) {*out_tab_data = std::move(tab_data);
            loop->Quit();
          },
          &loop,
          out_tab_data));
  loop.Run();
}

TabDataPtr ActorHandlerAsyncWaiter::CreateActorTab(
    int32_t task_id, CreateActorTabOptionsPtr options) {
  TabDataPtr async_wait_result;
  CreateActorTab(std::move(task_id),std::move(options),&async_wait_result);
  return async_wait_result;
}

void ActorHandlerAsyncWaiter::JournalSnapshot(
    bool clear_journal, JournalPtr* out_journal) {
  base::RunLoop loop;
  proxy_->JournalSnapshot(
      std::move(clear_journal),
      base::BindOnce(
          [](base::RunLoop* loop,
             JournalPtr* out_journal
,
             JournalPtr journal) {*out_journal = std::move(journal);
            loop->Quit();
          },
          &loop,
          out_journal));
  loop.Run();
}

JournalPtr ActorHandlerAsyncWaiter::JournalSnapshot(
    bool clear_journal) {
  JournalPtr async_wait_result;
  JournalSnapshot(std::move(clear_journal),&async_wait_result);
  return async_wait_result;
}




void AnnotationHandlerInterceptorForTesting::ScrollTo(ScrollToParamsPtr params, ScrollToCallback callback) {
  GetForwardingInterface()->ScrollTo(
    std::move(params)
    , std::move(callback));
}
void AnnotationHandlerInterceptorForTesting::DropScrollToHighlight() {
  GetForwardingInterface()->DropScrollToHighlight();
}
AnnotationHandlerAsyncWaiter::AnnotationHandlerAsyncWaiter(
    AnnotationHandler* proxy) : proxy_(proxy) {}

AnnotationHandlerAsyncWaiter::~AnnotationHandlerAsyncWaiter() = default;


void AnnotationHandlerAsyncWaiter::ScrollTo(
    ScrollToParamsPtr params, std::optional<ScrollToErrorReason>* out_error_reason) {
  base::RunLoop loop;
  proxy_->ScrollTo(
      std::move(params),
      base::BindOnce(
          [](base::RunLoop* loop,
             std::optional<ScrollToErrorReason>* out_error_reason
,
             std::optional<ScrollToErrorReason> error_reason) {*out_error_reason = std::move(error_reason);
            loop->Quit();
          },
          &loop,
          out_error_reason));
  loop.Run();
}

std::optional<ScrollToErrorReason> AnnotationHandlerAsyncWaiter::ScrollTo(
    ScrollToParamsPtr params) {
  std::optional<ScrollToErrorReason> async_wait_result;
  ScrollTo(std::move(params),&async_wait_result);
  return async_wait_result;
}




void SkillsHandlerInterceptorForTesting::CreateSkill(CreateSkillRequestPtr request, CreateSkillCallback callback) {
  GetForwardingInterface()->CreateSkill(
    std::move(request)
    , std::move(callback));
}
void SkillsHandlerInterceptorForTesting::UpdateSkill(UpdateSkillRequestPtr request, UpdateSkillCallback callback) {
  GetForwardingInterface()->UpdateSkill(
    std::move(request)
    , std::move(callback));
}
void SkillsHandlerInterceptorForTesting::ShowManageSkillsUi() {
  GetForwardingInterface()->ShowManageSkillsUi();
}
void SkillsHandlerInterceptorForTesting::ShowBrowseSkillsUi() {
  GetForwardingInterface()->ShowBrowseSkillsUi();
}
void SkillsHandlerInterceptorForTesting::GetSkill(const std::string& id, GetSkillCallback callback) {
  GetForwardingInterface()->GetSkill(
    std::move(id)
    , std::move(callback));
}
void SkillsHandlerInterceptorForTesting::RecordSkillsWebClientEvent(SkillsWebClientEvent event) {
  GetForwardingInterface()->RecordSkillsWebClientEvent(
    std::move(event)
    );
}
SkillsHandlerAsyncWaiter::SkillsHandlerAsyncWaiter(
    SkillsHandler* proxy) : proxy_(proxy) {}

SkillsHandlerAsyncWaiter::~SkillsHandlerAsyncWaiter() = default;


void SkillsHandlerAsyncWaiter::CreateSkill(
    CreateSkillRequestPtr request, bool* out_modal_opened) {
  base::RunLoop loop;
  proxy_->CreateSkill(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_modal_opened
,
             bool modal_opened) {*out_modal_opened = std::move(modal_opened);
            loop->Quit();
          },
          &loop,
          out_modal_opened));
  loop.Run();
}

bool SkillsHandlerAsyncWaiter::CreateSkill(
    CreateSkillRequestPtr request) {
  bool async_wait_result;
  CreateSkill(std::move(request),&async_wait_result);
  return async_wait_result;
}

void SkillsHandlerAsyncWaiter::UpdateSkill(
    UpdateSkillRequestPtr request, bool* out_modal_opened) {
  base::RunLoop loop;
  proxy_->UpdateSkill(
      std::move(request),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_modal_opened
,
             bool modal_opened) {*out_modal_opened = std::move(modal_opened);
            loop->Quit();
          },
          &loop,
          out_modal_opened));
  loop.Run();
}

bool SkillsHandlerAsyncWaiter::UpdateSkill(
    UpdateSkillRequestPtr request) {
  bool async_wait_result;
  UpdateSkill(std::move(request),&async_wait_result);
  return async_wait_result;
}

void SkillsHandlerAsyncWaiter::GetSkill(
    const std::string& id, SkillPtr* out_skill) {
  base::RunLoop loop;
  proxy_->GetSkill(
      std::move(id),
      base::BindOnce(
          [](base::RunLoop* loop,
             SkillPtr* out_skill
,
             SkillPtr skill) {*out_skill = std::move(skill);
            loop->Quit();
          },
          &loop,
          out_skill));
  loop.Run();
}

SkillPtr SkillsHandlerAsyncWaiter::GetSkill(
    const std::string& id) {
  SkillPtr async_wait_result;
  GetSkill(std::move(id),&async_wait_result);
  return async_wait_result;
}




void SkillsClientInterceptorForTesting::NotifySkillPreviewsChanged(std::vector<SkillPreviewPtr> skill_previews) {
  GetForwardingInterface()->NotifySkillPreviewsChanged(
    std::move(skill_previews)
    );
}
void SkillsClientInterceptorForTesting::NotifyContextualSkillPreviewsChanged(std::vector<SkillPreviewPtr> skill_previews) {
  GetForwardingInterface()->NotifyContextualSkillPreviewsChanged(
    std::move(skill_previews)
    );
}
void SkillsClientInterceptorForTesting::NotifySkillPreviewChanged(SkillPreviewPtr skill_preview) {
  GetForwardingInterface()->NotifySkillPreviewChanged(
    std::move(skill_preview)
    );
}
void SkillsClientInterceptorForTesting::NotifySkillDeleted(const std::string& skill_id) {
  GetForwardingInterface()->NotifySkillDeleted(
    std::move(skill_id)
    );
}
void SkillsClientInterceptorForTesting::NotifySkillsEnabledChanged(bool enabled) {
  GetForwardingInterface()->NotifySkillsEnabledChanged(
    std::move(enabled)
    );
}
SkillsClientAsyncWaiter::SkillsClientAsyncWaiter(
    SkillsClient* proxy) : proxy_(proxy) {}

SkillsClientAsyncWaiter::~SkillsClientAsyncWaiter() = default;





void WebClientHandlerInterceptorForTesting::WebClientCreated(::mojo::PendingRemote<WebClient> web_client, WebClientCreatedCallback callback) {
  GetForwardingInterface()->WebClientCreated(
    std::move(web_client)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::WebClientInitialized() {
  GetForwardingInterface()->WebClientInitialized();
}
void WebClientHandlerInterceptorForTesting::WebClientInitializeFailed() {
  GetForwardingInterface()->WebClientInitializeFailed();
}
void WebClientHandlerInterceptorForTesting::CreateActorHandler(::mojo::PendingReceiver<ActorHandler> receiver, ::mojo::PendingRemote<ActorClient> client) {
  GetForwardingInterface()->CreateActorHandler(
    std::move(receiver)
    , 
    std::move(client)
    );
}
void WebClientHandlerInterceptorForTesting::CreateExperimentalTriggeringClient(::mojo::PendingRemote<ExperimentalTriggeringClient> client) {
  GetForwardingInterface()->CreateExperimentalTriggeringClient(
    std::move(client)
    );
}
void WebClientHandlerInterceptorForTesting::CreateAnnotationHandler(::mojo::PendingReceiver<AnnotationHandler> receiver) {
  GetForwardingInterface()->CreateAnnotationHandler(
    std::move(receiver)
    );
}
void WebClientHandlerInterceptorForTesting::CreateSkillsHandler(::mojo::PendingReceiver<SkillsHandler> receiver, ::mojo::PendingRemote<SkillsClient> client) {
  GetForwardingInterface()->CreateSkillsHandler(
    std::move(receiver)
    , 
    std::move(client)
    );
}
void WebClientHandlerInterceptorForTesting::CreateZeroStateSuggestionsHandler(::mojo::PendingReceiver<ZeroStateSuggestionsHandler> receiver) {
  GetForwardingInterface()->CreateZeroStateSuggestionsHandler(
    std::move(receiver)
    );
}
void WebClientHandlerInterceptorForTesting::CreateTab(const ::GURL& url, CreateTabOptionsPtr create_options, CreateTabCallback callback) {
  GetForwardingInterface()->CreateTab(
    std::move(url)
    , 
    std::move(create_options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::ActivateTabWithUrl(const ::GURL& exact_url, ActivateTabOptionsPtr options, ActivateTabWithUrlCallback callback) {
  GetForwardingInterface()->ActivateTabWithUrl(
    std::move(exact_url)
    , 
    std::move(options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::OpenLinkInPopup(const ::GURL& url, int32_t popup_width, int32_t popup_height) {
  GetForwardingInterface()->OpenLinkInPopup(
    std::move(url)
    , 
    std::move(popup_width)
    , 
    std::move(popup_height)
    );
}
void WebClientHandlerInterceptorForTesting::OpenGlicSettingsPage(OpenSettingsOptionsPtr options) {
  GetForwardingInterface()->OpenGlicSettingsPage(
    std::move(options)
    );
}
void WebClientHandlerInterceptorForTesting::OpenPasswordManagerSettingsPage() {
  GetForwardingInterface()->OpenPasswordManagerSettingsPage();
}
void WebClientHandlerInterceptorForTesting::EnableDragResize(bool enabled) {
  GetForwardingInterface()->EnableDragResize(
    std::move(enabled)
    );
}
void WebClientHandlerInterceptorForTesting::ClosePanel() {
  GetForwardingInterface()->ClosePanel();
}
void WebClientHandlerInterceptorForTesting::ClosePanelAndShutdown() {
  GetForwardingInterface()->ClosePanelAndShutdown();
}
void WebClientHandlerInterceptorForTesting::AttachPanel() {
  GetForwardingInterface()->AttachPanel();
}
void WebClientHandlerInterceptorForTesting::DetachPanel() {
  GetForwardingInterface()->DetachPanel();
}
void WebClientHandlerInterceptorForTesting::OnModeChange(WebClientMode new_mode) {
  GetForwardingInterface()->OnModeChange(
    std::move(new_mode)
    );
}
void WebClientHandlerInterceptorForTesting::OnMicrophoneStatusChange(MicrophoneStatus status) {
  GetForwardingInterface()->OnMicrophoneStatusChange(
    std::move(status)
    );
}
void WebClientHandlerInterceptorForTesting::ShowProfilePicker() {
  GetForwardingInterface()->ShowProfilePicker();
}
void WebClientHandlerInterceptorForTesting::GetModelQualityClientId(GetModelQualityClientIdCallback callback) {
  GetForwardingInterface()->GetModelQualityClientId(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::GetContextFromFocusedTab(TabContextOptionsPtr options, GetContextFromFocusedTabCallback callback) {
  GetForwardingInterface()->GetContextFromFocusedTab(
    std::move(options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::GetContextFromTab(int32_t tab_id, TabContextOptionsPtr options, GetContextFromTabCallback callback) {
  GetForwardingInterface()->GetContextFromTab(
    std::move(tab_id)
    , 
    std::move(options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::GetImageBytesFromTab(int32_t tab_id, const std::string& document_id, int32_t dom_node_id, GetImageBytesFromTabCallback callback) {
  GetForwardingInterface()->GetImageBytesFromTab(
    std::move(tab_id)
    , 
    std::move(document_id)
    , 
    std::move(dom_node_id)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetMaximumNumberOfPinnedTabs(uint32_t requested_max, SetMaximumNumberOfPinnedTabsCallback callback) {
  GetForwardingInterface()->SetMaximumNumberOfPinnedTabs(
    std::move(requested_max)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::PinTabs(const std::vector<int32_t>& tab_ids, PinTabsOptionsPtr options, PinTabsCallback callback) {
  GetForwardingInterface()->PinTabs(
    std::move(tab_ids)
    , 
    std::move(options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::UnpinTabs(const std::vector<int32_t>& tab_ids, UnpinTabsOptionsPtr options, UnpinTabsCallback callback) {
  GetForwardingInterface()->UnpinTabs(
    std::move(tab_ids)
    , 
    std::move(options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::UnpinAllTabs(UnpinTabsOptionsPtr options) {
  GetForwardingInterface()->UnpinAllTabs(
    std::move(options)
    );
}
void WebClientHandlerInterceptorForTesting::SubscribeToPinCandidates(GetPinCandidatesOptionsPtr options, ::mojo::PendingRemote<PinCandidatesObserver> observer) {
  GetForwardingInterface()->SubscribeToPinCandidates(
    std::move(options)
    , 
    std::move(observer)
    );
}
void WebClientHandlerInterceptorForTesting::OpenPinnedTabPicker(OpenPinnedTabPickerOptionsPtr options, OpenPinnedTabPickerCallback callback) {
  GetForwardingInterface()->OpenPinnedTabPicker(
    std::move(options)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::ActivateTab(int32_t task_id) {
  GetForwardingInterface()->ActivateTab(
    std::move(task_id)
    );
}
void WebClientHandlerInterceptorForTesting::ResizeWidget(const ::gfx::Size& size, ::base::TimeDelta duration, ResizeWidgetCallback callback) {
  GetForwardingInterface()->ResizeWidget(
    std::move(size)
    , 
    std::move(duration)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::CaptureScreenshot(CaptureScreenshotCallback callback) {
  GetForwardingInterface()->CaptureScreenshot(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::CaptureRegion(::mojo::PendingRemote<CaptureRegionObserver> observer, CaptureRegionParamsPtr params) {
  GetForwardingInterface()->CaptureRegion(
    std::move(observer)
    , 
    std::move(params)
    );
}
void WebClientHandlerInterceptorForTesting::DeleteCapturedRegion(int32_t tab_id, const ::base::UnguessableToken& id) {
  GetForwardingInterface()->DeleteCapturedRegion(
    std::move(tab_id)
    , 
    std::move(id)
    );
}
void WebClientHandlerInterceptorForTesting::SetAudioDucking(bool enable, SetAudioDuckingCallback callback) {
  GetForwardingInterface()->SetAudioDucking(
    std::move(enable)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetMinimumPanelSize(const ::gfx::Size& size) {
  GetForwardingInterface()->SetMinimumPanelSize(
    std::move(size)
    );
}
void WebClientHandlerInterceptorForTesting::SetMicrophonePermissionState(bool enabled, SetMicrophonePermissionStateCallback callback) {
  GetForwardingInterface()->SetMicrophonePermissionState(
    std::move(enabled)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetLocationPermissionState(bool enabled, SetLocationPermissionStateCallback callback) {
  GetForwardingInterface()->SetLocationPermissionState(
    std::move(enabled)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetTabContextPermissionState(bool enabled, SetTabContextPermissionStateCallback callback) {
  GetForwardingInterface()->SetTabContextPermissionState(
    std::move(enabled)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetClosedCaptioningSetting(bool enabled, SetClosedCaptioningSettingCallback callback) {
  GetForwardingInterface()->SetClosedCaptioningSetting(
    std::move(enabled)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetActuationOnWebSetting(bool enabled, SetActuationOnWebSettingCallback callback) {
  GetForwardingInterface()->SetActuationOnWebSetting(
    std::move(enabled)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::ShouldAllowMediaPermissionRequest(ShouldAllowMediaPermissionRequestCallback callback) {
  GetForwardingInterface()->ShouldAllowMediaPermissionRequest(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::ShouldAllowGeolocationPermissionRequest(ShouldAllowGeolocationPermissionRequestCallback callback) {
  GetForwardingInterface()->ShouldAllowGeolocationPermissionRequest(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetContextAccessIndicator(bool enabled) {
  GetForwardingInterface()->SetContextAccessIndicator(
    std::move(enabled)
    );
}
void WebClientHandlerInterceptorForTesting::GetUserProfileInfo(GetUserProfileInfoCallback callback) {
  GetForwardingInterface()->GetUserProfileInfo(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SyncCookies(SyncCookiesCallback callback) {
  GetForwardingInterface()->SyncCookies(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::ClientErrorDialogStateChanged(std::optional<ClientErrorDialogType> shown_dialog_type) {
  GetForwardingInterface()->ClientErrorDialogStateChanged(
    std::move(shown_dialog_type)
    );
}
void WebClientHandlerInterceptorForTesting::ReportClientTransientError(::mojo_base::mojom::AbslStatusCode status_code) {
  GetForwardingInterface()->ReportClientTransientError(
    std::move(status_code)
    );
}
void WebClientHandlerInterceptorForTesting::ProcessCounterAbuseVerdict(int32_t tab_id, CounterAbuseVerdictPtr verdict) {
  GetForwardingInterface()->ProcessCounterAbuseVerdict(
    std::move(tab_id)
    , 
    std::move(verdict)
    );
}
void WebClientHandlerInterceptorForTesting::OnOptinImpression() {
  GetForwardingInterface()->OnOptinImpression();
}
void WebClientHandlerInterceptorForTesting::OnUserInputSubmitted(WebClientMode mode, PromptType prompt_type) {
  GetForwardingInterface()->OnUserInputSubmitted(
    std::move(mode)
    , 
    std::move(prompt_type)
    );
}
void WebClientHandlerInterceptorForTesting::OnContextUploadStarted() {
  GetForwardingInterface()->OnContextUploadStarted();
}
void WebClientHandlerInterceptorForTesting::OnContextUploadCompleted() {
  GetForwardingInterface()->OnContextUploadCompleted();
}
void WebClientHandlerInterceptorForTesting::OnReaction(MetricUserInputReactionType reactionType) {
  GetForwardingInterface()->OnReaction(
    std::move(reactionType)
    );
}
void WebClientHandlerInterceptorForTesting::OnResponseStarted() {
  GetForwardingInterface()->OnResponseStarted();
}
void WebClientHandlerInterceptorForTesting::OnResponseStopped(OnResponseStoppedDetailsPtr details) {
  GetForwardingInterface()->OnResponseStopped(
    std::move(details)
    );
}
void WebClientHandlerInterceptorForTesting::OnSessionTerminated() {
  GetForwardingInterface()->OnSessionTerminated();
}
void WebClientHandlerInterceptorForTesting::OnTurnCompleted(WebClientModel model, ::base::TimeDelta duration) {
  GetForwardingInterface()->OnTurnCompleted(
    std::move(model)
    , 
    std::move(duration)
    );
}
void WebClientHandlerInterceptorForTesting::OnResponseRated(bool positive) {
  GetForwardingInterface()->OnResponseRated(
    std::move(positive)
    );
}
void WebClientHandlerInterceptorForTesting::OnClosedCaptionsShown() {
  GetForwardingInterface()->OnClosedCaptionsShown();
}
void WebClientHandlerInterceptorForTesting::OnActionSubmitted(bool is_retry) {
  GetForwardingInterface()->OnActionSubmitted(
    std::move(is_retry)
    );
}
void WebClientHandlerInterceptorForTesting::SetSyntheticExperimentState(const std::string& trial_name, const std::string& group_name) {
  GetForwardingInterface()->SetSyntheticExperimentState(
    std::move(trial_name)
    , 
    std::move(group_name)
    );
}
void WebClientHandlerInterceptorForTesting::OpenOsPermissionSettingsMenu(::content_settings::mojom::ContentSettingsType type) {
  GetForwardingInterface()->OpenOsPermissionSettingsMenu(
    std::move(type)
    );
}
void WebClientHandlerInterceptorForTesting::GetOsMicrophonePermissionStatus(GetOsMicrophonePermissionStatusCallback callback) {
  GetForwardingInterface()->GetOsMicrophonePermissionStatus(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::GetZeroStateSuggestionsForFocusedTab(std::optional<bool> is_first_run, GetZeroStateSuggestionsForFocusedTabCallback callback) {
  GetForwardingInterface()->GetZeroStateSuggestionsForFocusedTab(
    std::move(is_first_run)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::MaybeRefreshUserStatus() {
  GetForwardingInterface()->MaybeRefreshUserStatus();
}
void WebClientHandlerInterceptorForTesting::IsDebuggerAttached(IsDebuggerAttachedCallback callback) {
  GetForwardingInterface()->IsDebuggerAttached(std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SubscribeToPageMetadata(int32_t tab_id, const std::vector<std::string>& names, SubscribeToPageMetadataCallback callback) {
  GetForwardingInterface()->SubscribeToPageMetadata(
    std::move(tab_id)
    , 
    std::move(names)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SwitchConversation(ConversationInfoPtr info, SwitchConversationCallback callback) {
  GetForwardingInterface()->SwitchConversation(
    std::move(info)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::RegisterConversation(ConversationInfoPtr info, RegisterConversationCallback callback) {
  GetForwardingInterface()->RegisterConversation(
    std::move(info)
    , std::move(callback));
}
void WebClientHandlerInterceptorForTesting::SetOnboardingCompleted() {
  GetForwardingInterface()->SetOnboardingCompleted();
}
void WebClientHandlerInterceptorForTesting::SubscribeToTabData(int32_t tab_id, ::mojo::PendingRemote<TabDataHandler> receiver) {
  GetForwardingInterface()->SubscribeToTabData(
    std::move(tab_id)
    , 
    std::move(receiver)
    );
}
void WebClientHandlerInterceptorForTesting::SubscribeToTabFavicon(int32_t tab_id, ::mojo::PendingRemote<TabFaviconHandler> receiver) {
  GetForwardingInterface()->SubscribeToTabFavicon(
    std::move(tab_id)
    , 
    std::move(receiver)
    );
}
WebClientHandlerAsyncWaiter::WebClientHandlerAsyncWaiter(
    WebClientHandler* proxy) : proxy_(proxy) {}

WebClientHandlerAsyncWaiter::~WebClientHandlerAsyncWaiter() = default;


void WebClientHandlerAsyncWaiter::WebClientCreated(
    ::mojo::PendingRemote<WebClient> web_client, WebClientInitialStatePtr* out_initial_state) {
  base::RunLoop loop;
  proxy_->WebClientCreated(
      std::move(web_client),
      base::BindOnce(
          [](base::RunLoop* loop,
             WebClientInitialStatePtr* out_initial_state
,
             WebClientInitialStatePtr initial_state) {*out_initial_state = std::move(initial_state);
            loop->Quit();
          },
          &loop,
          out_initial_state));
  loop.Run();
}

WebClientInitialStatePtr WebClientHandlerAsyncWaiter::WebClientCreated(
    ::mojo::PendingRemote<WebClient> web_client) {
  WebClientInitialStatePtr async_wait_result;
  WebClientCreated(std::move(web_client),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::CreateTab(
    const ::GURL& url, CreateTabOptionsPtr create_options, TabDataPtr* out_tab_data) {
  base::RunLoop loop;
  proxy_->CreateTab(
      std::move(url),
      std::move(create_options),
      base::BindOnce(
          [](base::RunLoop* loop,
             TabDataPtr* out_tab_data
,
             TabDataPtr tab_data) {*out_tab_data = std::move(tab_data);
            loop->Quit();
          },
          &loop,
          out_tab_data));
  loop.Run();
}

TabDataPtr WebClientHandlerAsyncWaiter::CreateTab(
    const ::GURL& url, CreateTabOptionsPtr create_options) {
  TabDataPtr async_wait_result;
  CreateTab(std::move(url),std::move(create_options),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::ActivateTabWithUrl(
    const ::GURL& exact_url, ActivateTabOptionsPtr options, TabDataPtr* out_tab_data) {
  base::RunLoop loop;
  proxy_->ActivateTabWithUrl(
      std::move(exact_url),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             TabDataPtr* out_tab_data
,
             TabDataPtr tab_data) {*out_tab_data = std::move(tab_data);
            loop->Quit();
          },
          &loop,
          out_tab_data));
  loop.Run();
}

TabDataPtr WebClientHandlerAsyncWaiter::ActivateTabWithUrl(
    const ::GURL& exact_url, ActivateTabOptionsPtr options) {
  TabDataPtr async_wait_result;
  ActivateTabWithUrl(std::move(exact_url),std::move(options),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetModelQualityClientId(
    std::string* out_model_quality_client_id) {
  base::RunLoop loop;
  proxy_->GetModelQualityClientId(
      base::BindOnce(
          [](base::RunLoop* loop,
             std::string* out_model_quality_client_id
,
             const std::string& model_quality_client_id) {*out_model_quality_client_id = std::move(model_quality_client_id);
            loop->Quit();
          },
          &loop,
          out_model_quality_client_id));
  loop.Run();
}

std::string WebClientHandlerAsyncWaiter::GetModelQualityClientId(
    ) {
  std::string async_wait_result;
  GetModelQualityClientId(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetContextFromFocusedTab(
    TabContextOptionsPtr options, GetContextResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->GetContextFromFocusedTab(
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             GetContextResultPtr* out_result
,
             GetContextResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

GetContextResultPtr WebClientHandlerAsyncWaiter::GetContextFromFocusedTab(
    TabContextOptionsPtr options) {
  GetContextResultPtr async_wait_result;
  GetContextFromFocusedTab(std::move(options),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetContextFromTab(
    int32_t tab_id, TabContextOptionsPtr options, GetContextResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->GetContextFromTab(
      std::move(tab_id),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             GetContextResultPtr* out_result
,
             GetContextResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

GetContextResultPtr WebClientHandlerAsyncWaiter::GetContextFromTab(
    int32_t tab_id, TabContextOptionsPtr options) {
  GetContextResultPtr async_wait_result;
  GetContextFromTab(std::move(tab_id),std::move(options),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetImageBytesFromTab(
    int32_t tab_id, const std::string& document_id, int32_t dom_node_id, GetImageBytesResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->GetImageBytesFromTab(
      std::move(tab_id),
      std::move(document_id),
      std::move(dom_node_id),
      base::BindOnce(
          [](base::RunLoop* loop,
             GetImageBytesResultPtr* out_result
,
             GetImageBytesResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

GetImageBytesResultPtr WebClientHandlerAsyncWaiter::GetImageBytesFromTab(
    int32_t tab_id, const std::string& document_id, int32_t dom_node_id) {
  GetImageBytesResultPtr async_wait_result;
  GetImageBytesFromTab(std::move(tab_id),std::move(document_id),std::move(dom_node_id),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::SetMaximumNumberOfPinnedTabs(
    uint32_t requested_max, uint32_t* out_effective_max) {
  base::RunLoop loop;
  proxy_->SetMaximumNumberOfPinnedTabs(
      std::move(requested_max),
      base::BindOnce(
          [](base::RunLoop* loop,
             uint32_t* out_effective_max
,
             uint32_t effective_max) {*out_effective_max = std::move(effective_max);
            loop->Quit();
          },
          &loop,
          out_effective_max));
  loop.Run();
}

uint32_t WebClientHandlerAsyncWaiter::SetMaximumNumberOfPinnedTabs(
    uint32_t requested_max) {
  uint32_t async_wait_result;
  SetMaximumNumberOfPinnedTabs(std::move(requested_max),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::PinTabs(
    const std::vector<int32_t>& tab_ids, PinTabsOptionsPtr options, bool* out_pinned_all) {
  base::RunLoop loop;
  proxy_->PinTabs(
      std::move(tab_ids),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_pinned_all
,
             bool pinned_all) {*out_pinned_all = std::move(pinned_all);
            loop->Quit();
          },
          &loop,
          out_pinned_all));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::PinTabs(
    const std::vector<int32_t>& tab_ids, PinTabsOptionsPtr options) {
  bool async_wait_result;
  PinTabs(std::move(tab_ids),std::move(options),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::UnpinTabs(
    const std::vector<int32_t>& tab_ids, UnpinTabsOptionsPtr options, bool* out_unpinned_all) {
  base::RunLoop loop;
  proxy_->UnpinTabs(
      std::move(tab_ids),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_unpinned_all
,
             bool unpinned_all) {*out_unpinned_all = std::move(unpinned_all);
            loop->Quit();
          },
          &loop,
          out_unpinned_all));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::UnpinTabs(
    const std::vector<int32_t>& tab_ids, UnpinTabsOptionsPtr options) {
  bool async_wait_result;
  UnpinTabs(std::move(tab_ids),std::move(options),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::OpenPinnedTabPicker(
    OpenPinnedTabPickerOptionsPtr options) {
  base::RunLoop loop;
  proxy_->OpenPinnedTabPicker(
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::ResizeWidget(
    const ::gfx::Size& size, ::base::TimeDelta duration) {
  base::RunLoop loop;
  proxy_->ResizeWidget(
      std::move(size),
      std::move(duration),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::CaptureScreenshot(
    CaptureScreenshotResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->CaptureScreenshot(
      base::BindOnce(
          [](base::RunLoop* loop,
             CaptureScreenshotResultPtr* out_result
,
             CaptureScreenshotResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

CaptureScreenshotResultPtr WebClientHandlerAsyncWaiter::CaptureScreenshot(
    ) {
  CaptureScreenshotResultPtr async_wait_result;
  CaptureScreenshot(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::SetAudioDucking(
    bool enable, bool* out_result) {
  base::RunLoop loop;
  proxy_->SetAudioDucking(
      std::move(enable),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_result
,
             bool result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::SetAudioDucking(
    bool enable) {
  bool async_wait_result;
  SetAudioDucking(std::move(enable),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::SetMicrophonePermissionState(
    bool enabled) {
  base::RunLoop loop;
  proxy_->SetMicrophonePermissionState(
      std::move(enabled),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::SetLocationPermissionState(
    bool enabled) {
  base::RunLoop loop;
  proxy_->SetLocationPermissionState(
      std::move(enabled),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::SetTabContextPermissionState(
    bool enabled) {
  base::RunLoop loop;
  proxy_->SetTabContextPermissionState(
      std::move(enabled),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::SetClosedCaptioningSetting(
    bool enabled) {
  base::RunLoop loop;
  proxy_->SetClosedCaptioningSetting(
      std::move(enabled),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::SetActuationOnWebSetting(
    bool enabled) {
  base::RunLoop loop;
  proxy_->SetActuationOnWebSetting(
      std::move(enabled),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientHandlerAsyncWaiter::ShouldAllowMediaPermissionRequest(
    bool* out_is_allowed) {
  base::RunLoop loop;
  proxy_->ShouldAllowMediaPermissionRequest(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_allowed
,
             bool is_allowed) {*out_is_allowed = std::move(is_allowed);
            loop->Quit();
          },
          &loop,
          out_is_allowed));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::ShouldAllowMediaPermissionRequest(
    ) {
  bool async_wait_result;
  ShouldAllowMediaPermissionRequest(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::ShouldAllowGeolocationPermissionRequest(
    bool* out_is_allowed) {
  base::RunLoop loop;
  proxy_->ShouldAllowGeolocationPermissionRequest(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_allowed
,
             bool is_allowed) {*out_is_allowed = std::move(is_allowed);
            loop->Quit();
          },
          &loop,
          out_is_allowed));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::ShouldAllowGeolocationPermissionRequest(
    ) {
  bool async_wait_result;
  ShouldAllowGeolocationPermissionRequest(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetUserProfileInfo(
    UserProfileInfoPtr* out_profile_info) {
  base::RunLoop loop;
  proxy_->GetUserProfileInfo(
      base::BindOnce(
          [](base::RunLoop* loop,
             UserProfileInfoPtr* out_profile_info
,
             UserProfileInfoPtr profile_info) {*out_profile_info = std::move(profile_info);
            loop->Quit();
          },
          &loop,
          out_profile_info));
  loop.Run();
}

UserProfileInfoPtr WebClientHandlerAsyncWaiter::GetUserProfileInfo(
    ) {
  UserProfileInfoPtr async_wait_result;
  GetUserProfileInfo(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::SyncCookies(
    bool* out_success) {
  base::RunLoop loop;
  proxy_->SyncCookies(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             bool success) {*out_success = std::move(success);
            loop->Quit();
          },
          &loop,
          out_success));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::SyncCookies(
    ) {
  bool async_wait_result;
  SyncCookies(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetOsMicrophonePermissionStatus(
    bool* out_enabled) {
  base::RunLoop loop;
  proxy_->GetOsMicrophonePermissionStatus(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_enabled
,
             bool enabled) {*out_enabled = std::move(enabled);
            loop->Quit();
          },
          &loop,
          out_enabled));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::GetOsMicrophonePermissionStatus(
    ) {
  bool async_wait_result;
  GetOsMicrophonePermissionStatus(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::GetZeroStateSuggestionsForFocusedTab(
    std::optional<bool> is_first_run, ZeroStateSuggestionsPtr* out_suggestions) {
  base::RunLoop loop;
  proxy_->GetZeroStateSuggestionsForFocusedTab(
      std::move(is_first_run),
      base::BindOnce(
          [](base::RunLoop* loop,
             ZeroStateSuggestionsPtr* out_suggestions
,
             ZeroStateSuggestionsPtr suggestions) {*out_suggestions = std::move(suggestions);
            loop->Quit();
          },
          &loop,
          out_suggestions));
  loop.Run();
}

ZeroStateSuggestionsPtr WebClientHandlerAsyncWaiter::GetZeroStateSuggestionsForFocusedTab(
    std::optional<bool> is_first_run) {
  ZeroStateSuggestionsPtr async_wait_result;
  GetZeroStateSuggestionsForFocusedTab(std::move(is_first_run),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::IsDebuggerAttached(
    bool* out_is_attached_to_webview) {
  base::RunLoop loop;
  proxy_->IsDebuggerAttached(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_attached_to_webview
,
             bool is_attached_to_webview) {*out_is_attached_to_webview = std::move(is_attached_to_webview);
            loop->Quit();
          },
          &loop,
          out_is_attached_to_webview));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::IsDebuggerAttached(
    ) {
  bool async_wait_result;
  IsDebuggerAttached(&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::SubscribeToPageMetadata(
    int32_t tab_id, const std::vector<std::string>& names, bool* out_success) {
  base::RunLoop loop;
  proxy_->SubscribeToPageMetadata(
      std::move(tab_id),
      std::move(names),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             bool success) {*out_success = std::move(success);
            loop->Quit();
          },
          &loop,
          out_success));
  loop.Run();
}

bool WebClientHandlerAsyncWaiter::SubscribeToPageMetadata(
    int32_t tab_id, const std::vector<std::string>& names) {
  bool async_wait_result;
  SubscribeToPageMetadata(std::move(tab_id),std::move(names),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::SwitchConversation(
    ConversationInfoPtr info, std::optional<SwitchConversationErrorReason>* out_error_reason) {
  base::RunLoop loop;
  proxy_->SwitchConversation(
      std::move(info),
      base::BindOnce(
          [](base::RunLoop* loop,
             std::optional<SwitchConversationErrorReason>* out_error_reason
,
             std::optional<SwitchConversationErrorReason> error_reason) {*out_error_reason = std::move(error_reason);
            loop->Quit();
          },
          &loop,
          out_error_reason));
  loop.Run();
}

std::optional<SwitchConversationErrorReason> WebClientHandlerAsyncWaiter::SwitchConversation(
    ConversationInfoPtr info) {
  std::optional<SwitchConversationErrorReason> async_wait_result;
  SwitchConversation(std::move(info),&async_wait_result);
  return async_wait_result;
}

void WebClientHandlerAsyncWaiter::RegisterConversation(
    ConversationInfoPtr info, std::optional<RegisterConversationErrorReason>* out_error_reason) {
  base::RunLoop loop;
  proxy_->RegisterConversation(
      std::move(info),
      base::BindOnce(
          [](base::RunLoop* loop,
             std::optional<RegisterConversationErrorReason>* out_error_reason
,
             std::optional<RegisterConversationErrorReason> error_reason) {*out_error_reason = std::move(error_reason);
            loop->Quit();
          },
          &loop,
          out_error_reason));
  loop.Run();
}

std::optional<RegisterConversationErrorReason> WebClientHandlerAsyncWaiter::RegisterConversation(
    ConversationInfoPtr info) {
  std::optional<RegisterConversationErrorReason> async_wait_result;
  RegisterConversation(std::move(info),&async_wait_result);
  return async_wait_result;
}




void ZeroStateSuggestionsHandlerInterceptorForTesting::GetZeroStateSuggestionsAndSubscribe(::mojo::PendingRemote<ZeroStateSuggestionsClient> client, ZeroStateSuggestionsOptionsPtr options, GetZeroStateSuggestionsAndSubscribeCallback callback) {
  GetForwardingInterface()->GetZeroStateSuggestionsAndSubscribe(
    std::move(client)
    , 
    std::move(options)
    , std::move(callback));
}
ZeroStateSuggestionsHandlerAsyncWaiter::ZeroStateSuggestionsHandlerAsyncWaiter(
    ZeroStateSuggestionsHandler* proxy) : proxy_(proxy) {}

ZeroStateSuggestionsHandlerAsyncWaiter::~ZeroStateSuggestionsHandlerAsyncWaiter() = default;


void ZeroStateSuggestionsHandlerAsyncWaiter::GetZeroStateSuggestionsAndSubscribe(
    ::mojo::PendingRemote<ZeroStateSuggestionsClient> client, ZeroStateSuggestionsOptionsPtr options, ZeroStateSuggestionsV2Ptr* out_zero_state_suggestions) {
  base::RunLoop loop;
  proxy_->GetZeroStateSuggestionsAndSubscribe(
      std::move(client),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             ZeroStateSuggestionsV2Ptr* out_zero_state_suggestions
,
             ZeroStateSuggestionsV2Ptr zero_state_suggestions) {*out_zero_state_suggestions = std::move(zero_state_suggestions);
            loop->Quit();
          },
          &loop,
          out_zero_state_suggestions));
  loop.Run();
}

ZeroStateSuggestionsV2Ptr ZeroStateSuggestionsHandlerAsyncWaiter::GetZeroStateSuggestionsAndSubscribe(
    ::mojo::PendingRemote<ZeroStateSuggestionsClient> client, ZeroStateSuggestionsOptionsPtr options) {
  ZeroStateSuggestionsV2Ptr async_wait_result;
  GetZeroStateSuggestionsAndSubscribe(std::move(client),std::move(options),&async_wait_result);
  return async_wait_result;
}




void ZeroStateSuggestionsClientInterceptorForTesting::NotifyZeroStateSuggestionsChanged(ZeroStateSuggestionsV2Ptr suggestions, ZeroStateSuggestionsOptionsPtr options) {
  GetForwardingInterface()->NotifyZeroStateSuggestionsChanged(
    std::move(suggestions)
    , 
    std::move(options)
    );
}
ZeroStateSuggestionsClientAsyncWaiter::ZeroStateSuggestionsClientAsyncWaiter(
    ZeroStateSuggestionsClient* proxy) : proxy_(proxy) {}

ZeroStateSuggestionsClientAsyncWaiter::~ZeroStateSuggestionsClientAsyncWaiter() = default;





void TabDataHandlerInterceptorForTesting::OnTabDataChanged(TabDataPtr tab_data) {
  GetForwardingInterface()->OnTabDataChanged(
    std::move(tab_data)
    );
}
TabDataHandlerAsyncWaiter::TabDataHandlerAsyncWaiter(
    TabDataHandler* proxy) : proxy_(proxy) {}

TabDataHandlerAsyncWaiter::~TabDataHandlerAsyncWaiter() = default;





void TabFaviconHandlerInterceptorForTesting::OnTabFaviconChanged(const ::SkBitmap& favicon) {
  GetForwardingInterface()->OnTabFaviconChanged(
    std::move(favicon)
    );
}
TabFaviconHandlerAsyncWaiter::TabFaviconHandlerAsyncWaiter(
    TabFaviconHandler* proxy) : proxy_(proxy) {}

TabFaviconHandlerAsyncWaiter::~TabFaviconHandlerAsyncWaiter() = default;





void ExperimentalTriggeringUpdatesHandlerInterceptorForTesting::OnUpdate(ExperimentalTriggeringUpdatePtr update, SubscriberObservationType observation) {
  GetForwardingInterface()->OnUpdate(
    std::move(update)
    , 
    std::move(observation)
    );
}
ExperimentalTriggeringUpdatesHandlerAsyncWaiter::ExperimentalTriggeringUpdatesHandlerAsyncWaiter(
    ExperimentalTriggeringUpdatesHandler* proxy) : proxy_(proxy) {}

ExperimentalTriggeringUpdatesHandlerAsyncWaiter::~ExperimentalTriggeringUpdatesHandlerAsyncWaiter() = default;





void ExperimentalTriggeringClientInterceptorForTesting::UploadEncryptedScreenshot(ScreenshotPtr screenshot, UploadEncryptedScreenshotCallback callback) {
  GetForwardingInterface()->UploadEncryptedScreenshot(
    std::move(screenshot)
    , std::move(callback));
}
void ExperimentalTriggeringClientInterceptorForTesting::GetExperimentalTriggeringUpdates(::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> handler, GetExperimentalTriggeringUpdatesCallback callback) {
  GetForwardingInterface()->GetExperimentalTriggeringUpdates(
    std::move(handler)
    , std::move(callback));
}
ExperimentalTriggeringClientAsyncWaiter::ExperimentalTriggeringClientAsyncWaiter(
    ExperimentalTriggeringClient* proxy) : proxy_(proxy) {}

ExperimentalTriggeringClientAsyncWaiter::~ExperimentalTriggeringClientAsyncWaiter() = default;


void ExperimentalTriggeringClientAsyncWaiter::UploadEncryptedScreenshot(
    ScreenshotPtr screenshot, std::optional<std::string>* out_file_token) {
  base::RunLoop loop;
  proxy_->UploadEncryptedScreenshot(
      std::move(screenshot),
      base::BindOnce(
          [](base::RunLoop* loop,
             std::optional<std::string>* out_file_token
,
             const std::optional<std::string>& file_token) {*out_file_token = std::move(file_token);
            loop->Quit();
          },
          &loop,
          out_file_token));
  loop.Run();
}

std::optional<std::string> ExperimentalTriggeringClientAsyncWaiter::UploadEncryptedScreenshot(
    ScreenshotPtr screenshot) {
  std::optional<std::string> async_wait_result;
  UploadEncryptedScreenshot(std::move(screenshot),&async_wait_result);
  return async_wait_result;
}

void ExperimentalTriggeringClientAsyncWaiter::GetExperimentalTriggeringUpdates(
    ::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> handler, bool* out_success) {
  base::RunLoop loop;
  proxy_->GetExperimentalTriggeringUpdates(
      std::move(handler),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             bool success) {*out_success = std::move(success);
            loop->Quit();
          },
          &loop,
          out_success));
  loop.Run();
}

bool ExperimentalTriggeringClientAsyncWaiter::GetExperimentalTriggeringUpdates(
    ::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> handler) {
  bool async_wait_result;
  GetExperimentalTriggeringUpdates(std::move(handler),&async_wait_result);
  return async_wait_result;
}




void WebClientInterceptorForTesting::CheckResponsive(CheckResponsiveCallback callback) {
  GetForwardingInterface()->CheckResponsive(std::move(callback));
}
void WebClientInterceptorForTesting::NotifyPanelWillOpen(PanelOpeningDataPtr panel_opening_data, NotifyPanelWillOpenCallback callback) {
  GetForwardingInterface()->NotifyPanelWillOpen(
    std::move(panel_opening_data)
    , std::move(callback));
}
void WebClientInterceptorForTesting::NotifyPanelWasClosed(NotifyPanelWasClosedCallback callback) {
  GetForwardingInterface()->NotifyPanelWasClosed(std::move(callback));
}
void WebClientInterceptorForTesting::NotifyPanelStateChange(PanelStatePtr panel_state) {
  GetForwardingInterface()->NotifyPanelStateChange(
    std::move(panel_state)
    );
}
void WebClientInterceptorForTesting::NotifyPanelActiveChange(bool panel_active) {
  GetForwardingInterface()->NotifyPanelActiveChange(
    std::move(panel_active)
    );
}
void WebClientInterceptorForTesting::NotifyPanelCanAttachChange(bool can_attach) {
  GetForwardingInterface()->NotifyPanelCanAttachChange(
    std::move(can_attach)
    );
}
void WebClientInterceptorForTesting::NotifyMicrophonePermissionStateChanged(bool enabled) {
  GetForwardingInterface()->NotifyMicrophonePermissionStateChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyFileUploadStateChanged(FileUploadPolicyState state) {
  GetForwardingInterface()->NotifyFileUploadStateChanged(
    std::move(state)
    );
}
void WebClientInterceptorForTesting::StopMicrophone(StopMicrophoneCallback callback) {
  GetForwardingInterface()->StopMicrophone(std::move(callback));
}
void WebClientInterceptorForTesting::NotifyLocationPermissionStateChanged(bool enabled) {
  GetForwardingInterface()->NotifyLocationPermissionStateChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyTabContextPermissionStateChanged(bool enabled) {
  GetForwardingInterface()->NotifyTabContextPermissionStateChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyOsLocationPermissionStateChanged(bool enabled) {
  GetForwardingInterface()->NotifyOsLocationPermissionStateChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyFocusedTabChanged(FocusedTabDataPtr focused_tab_data) {
  GetForwardingInterface()->NotifyFocusedTabChanged(
    std::move(focused_tab_data)
    );
}
void WebClientInterceptorForTesting::NotifyManualResizeChanged(bool resizing) {
  GetForwardingInterface()->NotifyManualResizeChanged(
    std::move(resizing)
    );
}
void WebClientInterceptorForTesting::NotifyOsHotkeyStateChanged(const std::string& hotkey) {
  GetForwardingInterface()->NotifyOsHotkeyStateChanged(
    std::move(hotkey)
    );
}
void WebClientInterceptorForTesting::NotifyBrowserIsOpenChanged(bool browser_is_open) {
  GetForwardingInterface()->NotifyBrowserIsOpenChanged(
    std::move(browser_is_open)
    );
}
void WebClientInterceptorForTesting::NotifyZoomLevelChanged(double zoom_factor) {
  GetForwardingInterface()->NotifyZoomLevelChanged(
    std::move(zoom_factor)
    );
}
void WebClientInterceptorForTesting::NotifyInstanceActivationChanged(bool instance_active) {
  GetForwardingInterface()->NotifyInstanceActivationChanged(
    std::move(instance_active)
    );
}
void WebClientInterceptorForTesting::NotifyClosedCaptioningSettingChanged(bool enabled) {
  GetForwardingInterface()->NotifyClosedCaptioningSettingChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyPinnedTabsChanged(std::vector<TabDataPtr> tab_data) {
  GetForwardingInterface()->NotifyPinnedTabsChanged(
    std::move(tab_data)
    );
}
void WebClientInterceptorForTesting::NotifyPinnedTabDataChanged(TabDataPtr tab_data) {
  GetForwardingInterface()->NotifyPinnedTabDataChanged(
    std::move(tab_data)
    );
}
void WebClientInterceptorForTesting::NotifyPageMetadataChanged(int32_t tab_id, ::blink::mojom::PageMetadataPtr metadata) {
  GetForwardingInterface()->NotifyPageMetadataChanged(
    std::move(tab_id)
    , 
    std::move(metadata)
    );
}
void WebClientInterceptorForTesting::NotifyDefaultTabContextPermissionStateChanged(bool enabled) {
  GetForwardingInterface()->NotifyDefaultTabContextPermissionStateChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyAdditionalContext(AdditionalContextPtr context) {
  GetForwardingInterface()->NotifyAdditionalContext(
    std::move(context)
    );
}
void WebClientInterceptorForTesting::NotifyActuationOnWebSettingChanged(bool enabled) {
  GetForwardingInterface()->NotifyActuationOnWebSettingChanged(
    std::move(enabled)
    );
}
void WebClientInterceptorForTesting::NotifyActOnWebCapabilityChanged(bool can_act_on_web) {
  GetForwardingInterface()->NotifyActOnWebCapabilityChanged(
    std::move(can_act_on_web)
    );
}
void WebClientInterceptorForTesting::NotifyOnboardingCompletedChanged(bool completed) {
  GetForwardingInterface()->NotifyOnboardingCompletedChanged(
    std::move(completed)
    );
}
void WebClientInterceptorForTesting::NotifyGeminiEnterpriseSettingsChanged(GeminiEnterpriseSettingsPtr settings) {
  GetForwardingInterface()->NotifyGeminiEnterpriseSettingsChanged(
    std::move(settings)
    );
}
void WebClientInterceptorForTesting::NotifyActorTaskListRowClicked(int32_t task_id) {
  GetForwardingInterface()->NotifyActorTaskListRowClicked(
    std::move(task_id)
    );
}
void WebClientInterceptorForTesting::Invoke(InvokeOptionsPtr options, InvokeCallback callback) {
  GetForwardingInterface()->Invoke(
    std::move(options)
    , std::move(callback));
}
WebClientAsyncWaiter::WebClientAsyncWaiter(
    WebClient* proxy) : proxy_(proxy) {}

WebClientAsyncWaiter::~WebClientAsyncWaiter() = default;


void WebClientAsyncWaiter::CheckResponsive(
    ) {
  base::RunLoop loop;
  proxy_->CheckResponsive(
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientAsyncWaiter::NotifyPanelWillOpen(
    PanelOpeningDataPtr panel_opening_data, OpenPanelInfoPtr* out_openPanelInfo) {
  base::RunLoop loop;
  proxy_->NotifyPanelWillOpen(
      std::move(panel_opening_data),
      base::BindOnce(
          [](base::RunLoop* loop,
             OpenPanelInfoPtr* out_openPanelInfo
,
             OpenPanelInfoPtr openPanelInfo) {*out_openPanelInfo = std::move(openPanelInfo);
            loop->Quit();
          },
          &loop,
          out_openPanelInfo));
  loop.Run();
}

OpenPanelInfoPtr WebClientAsyncWaiter::NotifyPanelWillOpen(
    PanelOpeningDataPtr panel_opening_data) {
  OpenPanelInfoPtr async_wait_result;
  NotifyPanelWillOpen(std::move(panel_opening_data),&async_wait_result);
  return async_wait_result;
}

void WebClientAsyncWaiter::NotifyPanelWasClosed(
    ) {
  base::RunLoop loop;
  proxy_->NotifyPanelWasClosed(
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientAsyncWaiter::StopMicrophone(
    ) {
  base::RunLoop loop;
  proxy_->StopMicrophone(
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void WebClientAsyncWaiter::Invoke(
    InvokeOptionsPtr options) {
  base::RunLoop loop;
  proxy_->Invoke(
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}






void CaptureRegionObserverInterceptorForTesting::OnUpdate(CaptureRegionResultPtr result, std::optional<CaptureRegionErrorReason> reason) {
  GetForwardingInterface()->OnUpdate(
    std::move(result)
    , 
    std::move(reason)
    );
}
CaptureRegionObserverAsyncWaiter::CaptureRegionObserverAsyncWaiter(
    CaptureRegionObserver* proxy) : proxy_(proxy) {}

CaptureRegionObserverAsyncWaiter::~CaptureRegionObserverAsyncWaiter() = default;







}  // glic::mojom


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