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

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


namespace glic::mojom {
TieredRolloutInfo::TieredRolloutInfo()
    : ai_subscription_tier(),
      is_eligible_for_tiered_rollout_v1(),
      is_eligible_for_tiered_rollout_v2(),
      is_eligible_overall(),
      glic_rollout_eligibility_pref(),
      tiered_rollout_v2_eligible_tiers(),
      preference_sync_status() {}

TieredRolloutInfo::TieredRolloutInfo(
    std::optional<int32_t> ai_subscription_tier_in,
    bool is_eligible_for_tiered_rollout_v1_in,
    bool is_eligible_for_tiered_rollout_v2_in,
    bool is_eligible_overall_in,
    bool glic_rollout_eligibility_pref_in,
    const std::string& tiered_rollout_v2_eligible_tiers_in,
    const std::string& preference_sync_status_in)
    : ai_subscription_tier(std::move(ai_subscription_tier_in)),
      is_eligible_for_tiered_rollout_v1(std::move(is_eligible_for_tiered_rollout_v1_in)),
      is_eligible_for_tiered_rollout_v2(std::move(is_eligible_for_tiered_rollout_v2_in)),
      is_eligible_overall(std::move(is_eligible_overall_in)),
      glic_rollout_eligibility_pref(std::move(glic_rollout_eligibility_pref_in)),
      tiered_rollout_v2_eligible_tiers(std::move(tiered_rollout_v2_eligible_tiers_in)),
      preference_sync_status(std::move(preference_sync_status_in)) {}

TieredRolloutInfo::~TieredRolloutInfo() = default;

void TieredRolloutInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "ai_subscription_tier"), this->ai_subscription_tier,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int32_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_eligible_for_tiered_rollout_v1"), this->is_eligible_for_tiered_rollout_v1,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_eligible_for_tiered_rollout_v2"), this->is_eligible_for_tiered_rollout_v2,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_eligible_overall"), this->is_eligible_overall,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_rollout_eligibility_pref"), this->glic_rollout_eligibility_pref,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tiered_rollout_v2_eligible_tiers"), this->tiered_rollout_v2_eligible_tiers,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "preference_sync_status"), this->preference_sync_status,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TieredRolloutInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
InternalsDataPayload::InternalsDataPayload()
    : enablement(),
      config(),
      show_error_allowed(),
      experimental_triggering_enabled(),
      debug_info(),
      tiered_rollout_info() {}

InternalsDataPayload::InternalsDataPayload(
    ::glic::mojom::ProfileEnablementPtr enablement_in,
    ::glic::mojom::ConfigInfoPtr config_in,
    bool show_error_allowed_in,
    bool experimental_triggering_enabled_in,
    InternalsDebugInfoPtr debug_info_in,
    TieredRolloutInfoPtr tiered_rollout_info_in)
    : enablement(std::move(enablement_in)),
      config(std::move(config_in)),
      show_error_allowed(std::move(show_error_allowed_in)),
      experimental_triggering_enabled(std::move(experimental_triggering_enabled_in)),
      debug_info(std::move(debug_info_in)),
      tiered_rollout_info(std::move(tiered_rollout_info_in)) {}

InternalsDataPayload::~InternalsDataPayload() = default;

void InternalsDataPayload::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "enablement"), this->enablement,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::ProfileEnablementPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "config"), this->config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::ConfigInfoPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "show_error_allowed"), this->show_error_allowed,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "experimental_triggering_enabled"), this->experimental_triggering_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "debug_info"), this->debug_info,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type InternalsDebugInfoPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tiered_rollout_info"), this->tiered_rollout_info,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type TieredRolloutInfoPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool InternalsDataPayload::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
InternalsDebugInfo::InternalsDebugInfo()
    : glic_actor_feature_enabled(),
      glic_rollout_feature_enabled(),
      glic_tiered_rollout_feature_enabled(),
      glic_tiered_rollout_v2_feature_enabled(),
      platform(),
      form_factor(),
      boolean_settings(),
      hotkey(),
      locale(),
      permanent_country_code(),
      session_country_code(),
      system_requirement_met(),
      os_version_supported(),
      anchor_entrypoint_override_active(),
      primary_account_needs_signed_in(),
      dogfood_status() {}

InternalsDebugInfo::InternalsDebugInfo(
    bool glic_actor_feature_enabled_in,
    bool glic_rollout_feature_enabled_in,
    bool glic_tiered_rollout_feature_enabled_in,
    bool glic_tiered_rollout_v2_feature_enabled_in,
    ::glic::mojom::Platform platform_in,
    ::glic::mojom::FormFactor form_factor_in,
    const base::flat_map<std::string, bool>& boolean_settings_in,
    const std::string& hotkey_in,
    const std::string& locale_in,
    const std::string& permanent_country_code_in,
    const std::string& session_country_code_in,
    bool system_requirement_met_in,
    bool os_version_supported_in,
    bool anchor_entrypoint_override_active_in,
    bool primary_account_needs_signed_in_in,
    const std::string& dogfood_status_in)
    : glic_actor_feature_enabled(std::move(glic_actor_feature_enabled_in)),
      glic_rollout_feature_enabled(std::move(glic_rollout_feature_enabled_in)),
      glic_tiered_rollout_feature_enabled(std::move(glic_tiered_rollout_feature_enabled_in)),
      glic_tiered_rollout_v2_feature_enabled(std::move(glic_tiered_rollout_v2_feature_enabled_in)),
      platform(std::move(platform_in)),
      form_factor(std::move(form_factor_in)),
      boolean_settings(std::move(boolean_settings_in)),
      hotkey(std::move(hotkey_in)),
      locale(std::move(locale_in)),
      permanent_country_code(std::move(permanent_country_code_in)),
      session_country_code(std::move(session_country_code_in)),
      system_requirement_met(std::move(system_requirement_met_in)),
      os_version_supported(std::move(os_version_supported_in)),
      anchor_entrypoint_override_active(std::move(anchor_entrypoint_override_active_in)),
      primary_account_needs_signed_in(std::move(primary_account_needs_signed_in_in)),
      dogfood_status(std::move(dogfood_status_in)) {}

InternalsDebugInfo::~InternalsDebugInfo() = default;

void InternalsDebugInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_actor_feature_enabled"), this->glic_actor_feature_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_rollout_feature_enabled"), this->glic_rollout_feature_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_tiered_rollout_feature_enabled"), this->glic_tiered_rollout_feature_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "glic_tiered_rollout_v2_feature_enabled"), this->glic_tiered_rollout_v2_feature_enabled,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "platform"), this->platform,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::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 ::glic::mojom::FormFactor>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "boolean_settings"), this->boolean_settings,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const base::flat_map<std::string, bool>&>"
#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(
      "locale"), this->locale,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "permanent_country_code"), this->permanent_country_code,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "session_country_code"), this->session_country_code,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "system_requirement_met"), this->system_requirement_met,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "os_version_supported"), this->os_version_supported,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "anchor_entrypoint_override_active"), this->anchor_entrypoint_override_active,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "primary_account_needs_signed_in"), this->primary_account_needs_signed_in,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "dogfood_status"), this->dogfood_status,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool InternalsDebugInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ScreenshotTestKeyConfiguration::ScreenshotTestKeyConfiguration()
    : public_key(),
      auth_secret() {}

ScreenshotTestKeyConfiguration::ScreenshotTestKeyConfiguration(
    const std::string& public_key_in,
    const std::string& auth_secret_in)
    : public_key(std::move(public_key_in)),
      auth_secret(std::move(auth_secret_in)) {}

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

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

bool ScreenshotTestKeyConfiguration::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TriggerInvokeFromInternalsOptions::TriggerInvokeFromInternalsOptions()
    : invocation_source(),
      prompts(),
      additional_context(),
      conversation(),
      feature_mode(),
      disable_zss(),
      zss_config(),
      skill_id(),
      error_message(),
      timeout(),
      auto_submit(),
      fre_override(::glic::mojom::FreOverride::kUnspecified),
      wait_for_panel_open(),
      focus_on_show(),
      fre_completion_wait_mode(FreCompletionWaitMode::kDefault),
      show_panel(),
      surface(),
      specific_tab_index(),
      specific_tabs_to_share_indices(),
      actuation_target(),
      payload(),
      take_screenshot(),
      key_config(),
      supersede_if_in_progress() {}

TriggerInvokeFromInternalsOptions::TriggerInvokeFromInternalsOptions(
    ::glic::mojom::InvocationSource invocation_source_in,
    std::vector<std::string> prompts_in,
    ::glic::mojom::AdditionalContextPtr additional_context_in,
    ::glic::mojom::InvokeConversationSelectionPtr conversation_in,
    std::optional<::glic::mojom::FeatureMode> feature_mode_in,
    bool disable_zss_in,
    ::glic::mojom::ZssConfigPtr zss_config_in,
    const std::optional<std::string>& skill_id_in,
    const std::optional<std::string>& error_message_in,
    std::optional<::base::TimeDelta> timeout_in,
    bool auto_submit_in,
    ::glic::mojom::FreOverride fre_override_in,
    bool wait_for_panel_open_in,
    std::optional<bool> focus_on_show_in,
    FreCompletionWaitMode fre_completion_wait_mode_in,
    std::optional<bool> show_panel_in,
    ::glic::mojom::InvokeTargetSurfacePtr surface_in,
    std::optional<int32_t> specific_tab_index_in,
    std::optional<std::vector<int32_t>> specific_tabs_to_share_indices_in,
    ::glic::mojom::ActuationTarget actuation_target_in,
    ::glic::mojom::InvocationPayloadPtr payload_in,
    bool take_screenshot_in,
    ScreenshotTestKeyConfigurationPtr key_config_in,
    bool supersede_if_in_progress_in)
    : invocation_source(std::move(invocation_source_in)),
      prompts(std::move(prompts_in)),
      additional_context(std::move(additional_context_in)),
      conversation(std::move(conversation_in)),
      feature_mode(std::move(feature_mode_in)),
      disable_zss(std::move(disable_zss_in)),
      zss_config(std::move(zss_config_in)),
      skill_id(std::move(skill_id_in)),
      error_message(std::move(error_message_in)),
      timeout(std::move(timeout_in)),
      auto_submit(std::move(auto_submit_in)),
      fre_override(std::move(fre_override_in)),
      wait_for_panel_open(std::move(wait_for_panel_open_in)),
      focus_on_show(std::move(focus_on_show_in)),
      fre_completion_wait_mode(std::move(fre_completion_wait_mode_in)),
      show_panel(std::move(show_panel_in)),
      surface(std::move(surface_in)),
      specific_tab_index(std::move(specific_tab_index_in)),
      specific_tabs_to_share_indices(std::move(specific_tabs_to_share_indices_in)),
      actuation_target(std::move(actuation_target_in)),
      payload(std::move(payload_in)),
      take_screenshot(std::move(take_screenshot_in)),
      key_config(std::move(key_config_in)),
      supersede_if_in_progress(std::move(supersede_if_in_progress_in)) {}

TriggerInvokeFromInternalsOptions::~TriggerInvokeFromInternalsOptions() = default;

void TriggerInvokeFromInternalsOptions::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 ::glic::mojom::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::vector<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "additional_context"), this->additional_context,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::AdditionalContextPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "conversation"), this->conversation,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::InvokeConversationSelectionPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "feature_mode"), this->feature_mode,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::glic::mojom::FeatureMode>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "disable_zss"), this->disable_zss,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "zss_config"), this->zss_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::ZssConfigPtr>"
#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(
      "error_message"), this->error_message,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "timeout"), this->timeout,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::base::TimeDelta>>"
#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(
      "fre_override"), this->fre_override,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::FreOverride>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "wait_for_panel_open"), this->wait_for_panel_open,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "focus_on_show"), this->focus_on_show,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fre_completion_wait_mode"), this->fre_completion_wait_mode,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type FreCompletionWaitMode>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "show_panel"), this->show_panel,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<bool>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "surface"), this->surface,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::InvokeTargetSurfacePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "specific_tab_index"), this->specific_tab_index,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int32_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "specific_tabs_to_share_indices"), this->specific_tabs_to_share_indices,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<int32_t>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "actuation_target"), this->actuation_target,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::ActuationTarget>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "payload"), this->payload,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::glic::mojom::InvocationPayloadPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "take_screenshot"), this->take_screenshot,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "key_config"), this->key_config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ScreenshotTestKeyConfigurationPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "supersede_if_in_progress"), this->supersede_if_in_progress,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

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

InternalsPageHandler::IPCStableHashFunction InternalsPageHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::InternalsPageHandler>(message.name())) {
    case messages::InternalsPageHandler::kGetInternalsDataPayload: {
      return &InternalsPageHandler::GetInternalsDataPayload_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kSetGuestUrlPresets: {
      return &InternalsPageHandler::SetGuestUrlPresets_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kTriggerInvokeFromInternalsAction: {
      return &InternalsPageHandler::TriggerInvokeFromInternalsAction_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kGetOpenTabs: {
      return &InternalsPageHandler::GetOpenTabs_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kSetWebContinuityOriginatingHostUrlPreset: {
      return &InternalsPageHandler::SetWebContinuityOriginatingHostUrlPreset_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kSetShowErrorAllowed: {
      return &InternalsPageHandler::SetShowErrorAllowed_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kShowExperimentalOptIn: {
      return &InternalsPageHandler::ShowExperimentalOptIn_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kRevokeExperimentalTriggeringConsent: {
      return &InternalsPageHandler::RevokeExperimentalTriggeringConsent_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kRevokeGlicConsent: {
      return &InternalsPageHandler::RevokeGlicConsent_Sym::IPCStableHash;
    }
    case messages::InternalsPageHandler::kRevokeActuationConsent: {
      return &InternalsPageHandler::RevokeActuationConsent_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* InternalsPageHandler::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::InternalsPageHandler>(message.name())) {
      case messages::InternalsPageHandler::kGetInternalsDataPayload:
            return "Receive glic::mojom::InternalsPageHandler::GetInternalsDataPayload";
      case messages::InternalsPageHandler::kSetGuestUrlPresets:
            return "Receive glic::mojom::InternalsPageHandler::SetGuestUrlPresets";
      case messages::InternalsPageHandler::kTriggerInvokeFromInternalsAction:
            return "Receive glic::mojom::InternalsPageHandler::TriggerInvokeFromInternalsAction";
      case messages::InternalsPageHandler::kGetOpenTabs:
            return "Receive glic::mojom::InternalsPageHandler::GetOpenTabs";
      case messages::InternalsPageHandler::kSetWebContinuityOriginatingHostUrlPreset:
            return "Receive glic::mojom::InternalsPageHandler::SetWebContinuityOriginatingHostUrlPreset";
      case messages::InternalsPageHandler::kSetShowErrorAllowed:
            return "Receive glic::mojom::InternalsPageHandler::SetShowErrorAllowed";
      case messages::InternalsPageHandler::kShowExperimentalOptIn:
            return "Receive glic::mojom::InternalsPageHandler::ShowExperimentalOptIn";
      case messages::InternalsPageHandler::kRevokeExperimentalTriggeringConsent:
            return "Receive glic::mojom::InternalsPageHandler::RevokeExperimentalTriggeringConsent";
      case messages::InternalsPageHandler::kRevokeGlicConsent:
            return "Receive glic::mojom::InternalsPageHandler::RevokeGlicConsent";
      case messages::InternalsPageHandler::kRevokeActuationConsent:
            return "Receive glic::mojom::InternalsPageHandler::RevokeActuationConsent";
    }
  } else {
    switch (static_cast<messages::InternalsPageHandler>(message.name())) {
      case messages::InternalsPageHandler::kGetInternalsDataPayload:
            return "Receive reply glic::mojom::InternalsPageHandler::GetInternalsDataPayload";
      case messages::InternalsPageHandler::kSetGuestUrlPresets:
            return "Receive reply glic::mojom::InternalsPageHandler::SetGuestUrlPresets";
      case messages::InternalsPageHandler::kTriggerInvokeFromInternalsAction:
            return "Receive reply glic::mojom::InternalsPageHandler::TriggerInvokeFromInternalsAction";
      case messages::InternalsPageHandler::kGetOpenTabs:
            return "Receive reply glic::mojom::InternalsPageHandler::GetOpenTabs";
      case messages::InternalsPageHandler::kSetWebContinuityOriginatingHostUrlPreset:
            return "Receive reply glic::mojom::InternalsPageHandler::SetWebContinuityOriginatingHostUrlPreset";
      case messages::InternalsPageHandler::kSetShowErrorAllowed:
            return "Receive reply glic::mojom::InternalsPageHandler::SetShowErrorAllowed";
      case messages::InternalsPageHandler::kShowExperimentalOptIn:
            return "Receive reply glic::mojom::InternalsPageHandler::ShowExperimentalOptIn";
      case messages::InternalsPageHandler::kRevokeExperimentalTriggeringConsent:
            return "Receive reply glic::mojom::InternalsPageHandler::RevokeExperimentalTriggeringConsent";
      case messages::InternalsPageHandler::kRevokeGlicConsent:
            return "Receive reply glic::mojom::InternalsPageHandler::RevokeGlicConsent";
      case messages::InternalsPageHandler::kRevokeActuationConsent:
            return "Receive reply glic::mojom::InternalsPageHandler::RevokeActuationConsent";
    }
  }
  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 InternalsPageHandler::GetInternalsDataPayload_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 = 0xd54e6bb4;  // IPCStableHash for glic::mojom::InternalsPageHandler::GetInternalsDataPayload
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::SetGuestUrlPresets_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 = 0xf581bc6d;  // IPCStableHash for glic::mojom::InternalsPageHandler::SetGuestUrlPresets
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::TriggerInvokeFromInternalsAction_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 = 0xad171d7f;  // IPCStableHash for glic::mojom::InternalsPageHandler::TriggerInvokeFromInternalsAction
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::GetOpenTabs_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 = 0x92166b21;  // IPCStableHash for glic::mojom::InternalsPageHandler::GetOpenTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::SetWebContinuityOriginatingHostUrlPreset_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 = 0x08cc720e;  // IPCStableHash for glic::mojom::InternalsPageHandler::SetWebContinuityOriginatingHostUrlPreset
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::SetShowErrorAllowed_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 = 0x037a456a;  // IPCStableHash for glic::mojom::InternalsPageHandler::SetShowErrorAllowed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::ShowExperimentalOptIn_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 = 0x3947011e;  // IPCStableHash for glic::mojom::InternalsPageHandler::ShowExperimentalOptIn
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::RevokeExperimentalTriggeringConsent_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 = 0x5870b100;  // IPCStableHash for glic::mojom::InternalsPageHandler::RevokeExperimentalTriggeringConsent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::RevokeGlicConsent_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 = 0x2b80e15b;  // IPCStableHash for glic::mojom::InternalsPageHandler::RevokeGlicConsent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t InternalsPageHandler::RevokeActuationConsent_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 = 0xccb3be08;  // IPCStableHash for glic::mojom::InternalsPageHandler::RevokeActuationConsent
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class InternalsPageHandler_GetInternalsDataPayload_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  InternalsPageHandler_GetInternalsDataPayload_ForwardToCallback(
      InternalsPageHandler::GetInternalsDataPayloadCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  InternalsPageHandler::GetInternalsDataPayloadCallback callback_;
};

class InternalsPageHandler_TriggerInvokeFromInternalsAction_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  InternalsPageHandler_TriggerInvokeFromInternalsAction_ForwardToCallback(
      InternalsPageHandler::TriggerInvokeFromInternalsActionCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  InternalsPageHandler::TriggerInvokeFromInternalsActionCallback callback_;
};

class InternalsPageHandler_GetOpenTabs_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  InternalsPageHandler_GetOpenTabs_ForwardToCallback(
      InternalsPageHandler::GetOpenTabsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  InternalsPageHandler::GetOpenTabsCallback callback_;
};

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

void InternalsPageHandlerProxy::GetInternalsDataPayload(
    GetInternalsDataPayloadCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::InternalsPageHandler::GetInternalsDataPayload");
#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::InternalsPageHandler::kGetInternalsDataPayload), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_GetInternalsDataPayload_Params_Data> params(
          message);
  params.Allocate();

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

void InternalsPageHandlerProxy::SetGuestUrlPresets(
    const ::GURL& in_autopush, const ::GURL& in_staging, const ::GURL& in_preprod, const ::GURL& in_prod) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::InternalsPageHandler::SetGuestUrlPresets", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("autopush"), in_autopush,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("staging"), in_staging,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("preprod"), in_preprod,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("prod"), in_prod,
                        "<value of type const ::GURL&>");
   });
#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::InternalsPageHandler::kSetGuestUrlPresets), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_SetGuestUrlPresets_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->autopush)::BaseType> autopush_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_autopush,
    autopush_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->autopush.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null autopush in InternalsPageHandler.SetGuestUrlPresets request");
  mojo::internal::MessageFragment<
      typename decltype(params->staging)::BaseType> staging_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_staging,
    staging_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->staging.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null staging in InternalsPageHandler.SetGuestUrlPresets request");
  mojo::internal::MessageFragment<
      typename decltype(params->preprod)::BaseType> preprod_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_preprod,
    preprod_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->preprod.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null preprod in InternalsPageHandler.SetGuestUrlPresets request");
  mojo::internal::MessageFragment<
      typename decltype(params->prod)::BaseType> prod_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_prod,
    prod_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("SetGuestUrlPresets");
#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 InternalsPageHandlerProxy::TriggerInvokeFromInternalsAction(
    TriggerInvokeFromInternalsOptionsPtr in_options, TriggerInvokeFromInternalsActionCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::InternalsPageHandler::TriggerInvokeFromInternalsAction", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type TriggerInvokeFromInternalsOptionsPtr>");
   });
#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::InternalsPageHandler::kTriggerInvokeFromInternalsAction), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_TriggerInvokeFromInternalsAction_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::TriggerInvokeFromInternalsOptionsDataView>(
    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 InternalsPageHandler.TriggerInvokeFromInternalsAction request");

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

void InternalsPageHandlerProxy::GetOpenTabs(
    GetOpenTabsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::InternalsPageHandler::GetOpenTabs");
#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::InternalsPageHandler::kGetOpenTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_GetOpenTabs_Params_Data> params(
          message);
  params.Allocate();

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

void InternalsPageHandlerProxy::SetWebContinuityOriginatingHostUrlPreset(
    const ::GURL& in_web_continuity_originating_host_url) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::InternalsPageHandler::SetWebContinuityOriginatingHostUrlPreset", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("web_continuity_originating_host_url"), in_web_continuity_originating_host_url,
                        "<value of type const ::GURL&>");
   });
#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::InternalsPageHandler::kSetWebContinuityOriginatingHostUrlPreset), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_SetWebContinuityOriginatingHostUrlPreset_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->web_continuity_originating_host_url)::BaseType> web_continuity_originating_host_url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_web_continuity_originating_host_url,
    web_continuity_originating_host_url_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("SetWebContinuityOriginatingHostUrlPreset");
#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 InternalsPageHandlerProxy::SetShowErrorAllowed(
    bool in_allowed) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::InternalsPageHandler::SetShowErrorAllowed", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("allowed"), in_allowed,
                        "<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::InternalsPageHandler::kSetShowErrorAllowed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_SetShowErrorAllowed_Params_Data> params(
          message);
  params.Allocate();

  params->allowed = in_allowed;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("SetShowErrorAllowed");
#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 InternalsPageHandlerProxy::ShowExperimentalOptIn(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::InternalsPageHandler::ShowExperimentalOptIn");
#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::InternalsPageHandler::kShowExperimentalOptIn), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_ShowExperimentalOptIn_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("ShowExperimentalOptIn");
#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 InternalsPageHandlerProxy::RevokeExperimentalTriggeringConsent(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::InternalsPageHandler::RevokeExperimentalTriggeringConsent");
#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::InternalsPageHandler::kRevokeExperimentalTriggeringConsent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_RevokeExperimentalTriggeringConsent_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("RevokeExperimentalTriggeringConsent");
#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 InternalsPageHandlerProxy::RevokeGlicConsent(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::InternalsPageHandler::RevokeGlicConsent");
#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::InternalsPageHandler::kRevokeGlicConsent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_RevokeGlicConsent_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("RevokeGlicConsent");
#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 InternalsPageHandlerProxy::RevokeActuationConsent(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send glic::mojom::InternalsPageHandler::RevokeActuationConsent");
#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::InternalsPageHandler::kRevokeActuationConsent), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_RevokeActuationConsent_Params_Data> params(
          message);
  params.Allocate();

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

  ~InternalsPageHandler_GetInternalsDataPayload_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:
  InternalsPageHandler_GetInternalsDataPayload_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)
        << "InternalsPageHandler::GetInternalsDataPayloadCallback 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(
      InternalsDataPayloadPtr in_internals_data);
};

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

  // Validation for InternalsPageHandler.0
  bool success = true;
  InternalsDataPayloadPtr p_internals_data{};
  InternalsPageHandler_GetInternalsDataPayload_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadInternalsData(&p_internals_data))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        InternalsPageHandler::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_internals_data));
  }
  return true;
}

void InternalsPageHandler_GetInternalsDataPayload_ProxyToResponder::Run(
    InternalsDataPayloadPtr in_internals_data) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::InternalsPageHandler::GetInternalsDataPayload", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("internals_data"), in_internals_data,
                        "<value of type InternalsDataPayloadPtr>");
   });
#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::InternalsPageHandler::kGetInternalsDataPayload), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_GetInternalsDataPayload_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->internals_data)::BaseType> internals_data_fragment(
          params.message());
  
  mojo::internal::Serialize<::glic::mojom::InternalsDataPayloadDataView>(
    in_internals_data,
    internals_data_fragment);

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

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

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

  ~InternalsPageHandler_TriggerInvokeFromInternalsAction_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:
  InternalsPageHandler_TriggerInvokeFromInternalsAction_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)
        << "InternalsPageHandler::TriggerInvokeFromInternalsActionCallback 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, const std::string& in_error_message);
};

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

  // Validation for InternalsPageHandler.2
  bool success = true;
  bool p_success{};
  std::string p_error_message{};
  InternalsPageHandler_TriggerInvokeFromInternalsAction_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_success = input_data_view.success();
  if (success && !input_data_view.ReadErrorMessage(&p_error_message))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        InternalsPageHandler::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_success), 
std::move(p_error_message));
  }
  return true;
}

void InternalsPageHandler_TriggerInvokeFromInternalsAction_ProxyToResponder::Run(
    bool in_success, const std::string& in_error_message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::InternalsPageHandler::TriggerInvokeFromInternalsAction", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("error_message"), in_error_message,
                        "<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::InternalsPageHandler::kTriggerInvokeFromInternalsAction), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_TriggerInvokeFromInternalsAction_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;
  mojo::internal::MessageFragment<
      typename decltype(params->error_message)::BaseType> error_message_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_error_message,
    error_message_fragment);

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

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

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

  ~InternalsPageHandler_GetOpenTabs_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:
  InternalsPageHandler_GetOpenTabs_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)
        << "InternalsPageHandler::GetOpenTabsCallback 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::vector<std::string>& in_tab_titles);
};

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

  // Validation for InternalsPageHandler.3
  bool success = true;
  std::vector<std::string> p_tab_titles{};
  InternalsPageHandler_GetOpenTabs_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadTabTitles(&p_tab_titles))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        InternalsPageHandler::Name_, 3, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_tab_titles));
  }
  return true;
}

void InternalsPageHandler_GetOpenTabs_ProxyToResponder::Run(
    const std::vector<std::string>& in_tab_titles) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply glic::mojom::InternalsPageHandler::GetOpenTabs", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_titles"), in_tab_titles,
                        "<value of type const std::vector<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::InternalsPageHandler::kGetOpenTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandler_GetOpenTabs_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->tab_titles)::BaseType>
      tab_titles_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& tab_titles_validate_params =
      mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
    in_tab_titles,
    tab_titles_fragment,
    &tab_titles_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(InternalsPageHandler::Name_);
  message.set_method_name("GetOpenTabs");
#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 InternalsPageHandlerStubDispatch::Accept(
    InternalsPageHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::InternalsPageHandler>(message->header()->name)) {
    case messages::InternalsPageHandler::kGetInternalsDataPayload: {
      break;
    }
    case messages::InternalsPageHandler::kSetGuestUrlPresets: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_SetGuestUrlPresets_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_SetGuestUrlPresets_Params_Data*>(
              message->mutable_payload());
      

      // Validation for InternalsPageHandler.1
      bool success = true;
      ::GURL p_autopush{};
      ::GURL p_staging{};
      ::GURL p_preprod{};
      ::GURL p_prod{};
      InternalsPageHandler_SetGuestUrlPresets_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadAutopush(&p_autopush))
        success = false;
      if (success && !input_data_view.ReadStaging(&p_staging))
        success = false;
      if (success && !input_data_view.ReadPreprod(&p_preprod))
        success = false;
      if (success && !input_data_view.ReadProd(&p_prod))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetGuestUrlPresets(        
        std::move(p_autopush), 
        std::move(p_staging), 
        std::move(p_preprod), 
        std::move(p_prod));
      return true;
    }
    case messages::InternalsPageHandler::kTriggerInvokeFromInternalsAction: {
      break;
    }
    case messages::InternalsPageHandler::kGetOpenTabs: {
      break;
    }
    case messages::InternalsPageHandler::kSetWebContinuityOriginatingHostUrlPreset: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_SetWebContinuityOriginatingHostUrlPreset_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_SetWebContinuityOriginatingHostUrlPreset_Params_Data*>(
              message->mutable_payload());
      

      // Validation for InternalsPageHandler.4
      bool success = true;
      ::GURL p_web_continuity_originating_host_url{};
      InternalsPageHandler_SetWebContinuityOriginatingHostUrlPreset_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadWebContinuityOriginatingHostUrl(&p_web_continuity_originating_host_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetWebContinuityOriginatingHostUrlPreset(        
        std::move(p_web_continuity_originating_host_url));
      return true;
    }
    case messages::InternalsPageHandler::kSetShowErrorAllowed: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_SetShowErrorAllowed_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_SetShowErrorAllowed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for InternalsPageHandler.5
      bool success = true;
      bool p_allowed{};
      InternalsPageHandler_SetShowErrorAllowed_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_allowed = input_data_view.allowed();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 5, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetShowErrorAllowed(        
        std::move(p_allowed));
      return true;
    }
    case messages::InternalsPageHandler::kShowExperimentalOptIn: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_ShowExperimentalOptIn_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_ShowExperimentalOptIn_Params_Data*>(
              message->mutable_payload());
      

      // Validation for InternalsPageHandler.6
      bool success = true;
      InternalsPageHandler_ShowExperimentalOptIn_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 6, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowExperimentalOptIn(        );
      return true;
    }
    case messages::InternalsPageHandler::kRevokeExperimentalTriggeringConsent: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_RevokeExperimentalTriggeringConsent_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_RevokeExperimentalTriggeringConsent_Params_Data*>(
              message->mutable_payload());
      

      // Validation for InternalsPageHandler.7
      bool success = true;
      InternalsPageHandler_RevokeExperimentalTriggeringConsent_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 7, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RevokeExperimentalTriggeringConsent(        );
      return true;
    }
    case messages::InternalsPageHandler::kRevokeGlicConsent: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_RevokeGlicConsent_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_RevokeGlicConsent_Params_Data*>(
              message->mutable_payload());
      

      // Validation for InternalsPageHandler.8
      bool success = true;
      InternalsPageHandler_RevokeGlicConsent_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 8, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RevokeGlicConsent(        );
      return true;
    }
    case messages::InternalsPageHandler::kRevokeActuationConsent: {
      DCHECK(message->is_serialized());
      internal::InternalsPageHandler_RevokeActuationConsent_Params_Data* params =
          reinterpret_cast<internal::InternalsPageHandler_RevokeActuationConsent_Params_Data*>(
              message->mutable_payload());
      

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

// static
bool InternalsPageHandlerStubDispatch::AcceptWithResponder(
    InternalsPageHandler* 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::InternalsPageHandler>(message->header()->name)) {
    case messages::InternalsPageHandler::kGetInternalsDataPayload: {
      internal::InternalsPageHandler_GetInternalsDataPayload_Params_Data* params =
          reinterpret_cast<
              internal::InternalsPageHandler_GetInternalsDataPayload_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for InternalsPageHandler.0
      bool success = true;
      InternalsPageHandler_GetInternalsDataPayload_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          InternalsPageHandler_GetInternalsDataPayload_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetInternalsDataPayload(std::move(callback));
      return true;
    }
    case messages::InternalsPageHandler::kSetGuestUrlPresets: {
      break;
    }
    case messages::InternalsPageHandler::kTriggerInvokeFromInternalsAction: {
      internal::InternalsPageHandler_TriggerInvokeFromInternalsAction_Params_Data* params =
          reinterpret_cast<
              internal::InternalsPageHandler_TriggerInvokeFromInternalsAction_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for InternalsPageHandler.2
      bool success = true;
      TriggerInvokeFromInternalsOptionsPtr p_options{};
      InternalsPageHandler_TriggerInvokeFromInternalsAction_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,
            InternalsPageHandler::Name_, 2, false);
        return false;
      }
      auto callback =
          InternalsPageHandler_TriggerInvokeFromInternalsAction_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->TriggerInvokeFromInternalsAction(        
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::InternalsPageHandler::kGetOpenTabs: {
      internal::InternalsPageHandler_GetOpenTabs_Params_Data* params =
          reinterpret_cast<
              internal::InternalsPageHandler_GetOpenTabs_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for InternalsPageHandler.3
      bool success = true;
      InternalsPageHandler_GetOpenTabs_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            InternalsPageHandler::Name_, 3, false);
        return false;
      }
      auto callback =
          InternalsPageHandler_GetOpenTabs_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetOpenTabs(std::move(callback));
      return true;
    }
    case messages::InternalsPageHandler::kSetWebContinuityOriginatingHostUrlPreset: {
      break;
    }
    case messages::InternalsPageHandler::kSetShowErrorAllowed: {
      break;
    }
    case messages::InternalsPageHandler::kShowExperimentalOptIn: {
      break;
    }
    case messages::InternalsPageHandler::kRevokeExperimentalTriggeringConsent: {
      break;
    }
    case messages::InternalsPageHandler::kRevokeGlicConsent: {
      break;
    }
    case messages::InternalsPageHandler::kRevokeActuationConsent: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kInternalsPageHandlerValidationInfo[] = {
    { &internal::InternalsPageHandler_GetInternalsDataPayload_Params_Data::Validate,
     &internal::InternalsPageHandler_GetInternalsDataPayload_ResponseParams_Data::Validate},
    { &internal::InternalsPageHandler_SetGuestUrlPresets_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::InternalsPageHandler_TriggerInvokeFromInternalsAction_Params_Data::Validate,
     &internal::InternalsPageHandler_TriggerInvokeFromInternalsAction_ResponseParams_Data::Validate},
    { &internal::InternalsPageHandler_GetOpenTabs_Params_Data::Validate,
     &internal::InternalsPageHandler_GetOpenTabs_ResponseParams_Data::Validate},
    { &internal::InternalsPageHandler_SetWebContinuityOriginatingHostUrlPreset_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::InternalsPageHandler_SetShowErrorAllowed_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::InternalsPageHandler_ShowExperimentalOptIn_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::InternalsPageHandler_RevokeExperimentalTriggeringConsent_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::InternalsPageHandler_RevokeGlicConsent_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::InternalsPageHandler_RevokeActuationConsent_Params_Data::Validate,
     nullptr /* no response */},
};

bool InternalsPageHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::InternalsPageHandler::Name_,
    kInternalsPageHandlerValidationInfo);
}

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

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


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

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

void InternalsPageHandlerFactoryProxy::CreateInternalsPageHandler(
    ::mojo::PendingReceiver<InternalsPageHandler> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send glic::mojom::InternalsPageHandlerFactory::CreateInternalsPageHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingReceiver<InternalsPageHandler>>");
   });
#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::InternalsPageHandlerFactory::kCreateInternalsPageHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::glic::mojom::internal::InternalsPageHandlerFactory_CreateInternalsPageHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::glic::mojom::InternalsPageHandlerInterfaceBase>>(
    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 InternalsPageHandlerFactory.CreateInternalsPageHandler request");

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

      // Validation for InternalsPageHandlerFactory.0
      bool success = true;
      ::mojo::PendingReceiver<InternalsPageHandler> p_receiver{};
      InternalsPageHandlerFactory_CreateInternalsPageHandler_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,
            InternalsPageHandlerFactory::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateInternalsPageHandler(        
        std::move(p_receiver));
      return true;
    }
  }
  return false;
}

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

bool InternalsPageHandlerFactoryRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::glic::mojom::InternalsPageHandlerFactory::Name_,
    kInternalsPageHandlerFactoryValidationInfo);
}



}  // glic::mojom


namespace mojo {


// static
bool StructTraits<::glic::mojom::TieredRolloutInfo::DataView, ::glic::mojom::TieredRolloutInfoPtr>::Read(
    ::glic::mojom::TieredRolloutInfo::DataView input,
    ::glic::mojom::TieredRolloutInfoPtr* output) {
  bool success = true;
  ::glic::mojom::TieredRolloutInfoPtr result(::glic::mojom::TieredRolloutInfo::New());
  
      if (success) {
        result->ai_subscription_tier = input.ai_subscription_tier();
      }
      if (success)
        result->is_eligible_for_tiered_rollout_v1 = input.is_eligible_for_tiered_rollout_v1();
      if (success)
        result->is_eligible_for_tiered_rollout_v2 = input.is_eligible_for_tiered_rollout_v2();
      if (success)
        result->is_eligible_overall = input.is_eligible_overall();
      if (success)
        result->glic_rollout_eligibility_pref = input.glic_rollout_eligibility_pref();
      if (success && !input.ReadTieredRolloutV2EligibleTiers(&result->tiered_rollout_v2_eligible_tiers))
        success = false;
      if (success && !input.ReadPreferenceSyncStatus(&result->preference_sync_status))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::InternalsDataPayload::DataView, ::glic::mojom::InternalsDataPayloadPtr>::Read(
    ::glic::mojom::InternalsDataPayload::DataView input,
    ::glic::mojom::InternalsDataPayloadPtr* output) {
  bool success = true;
  ::glic::mojom::InternalsDataPayloadPtr result(::glic::mojom::InternalsDataPayload::New());
  
      if (success && !input.ReadEnablement(&result->enablement))
        success = false;
      if (success && !input.ReadConfig(&result->config))
        success = false;
      if (success)
        result->show_error_allowed = input.show_error_allowed();
      if (success)
        result->experimental_triggering_enabled = input.experimental_triggering_enabled();
      if (success && !input.ReadDebugInfo(&result->debug_info))
        success = false;
      if (success && !input.ReadTieredRolloutInfo(&result->tiered_rollout_info))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::InternalsDebugInfo::DataView, ::glic::mojom::InternalsDebugInfoPtr>::Read(
    ::glic::mojom::InternalsDebugInfo::DataView input,
    ::glic::mojom::InternalsDebugInfoPtr* output) {
  bool success = true;
  ::glic::mojom::InternalsDebugInfoPtr result(::glic::mojom::InternalsDebugInfo::New());
  
      if (success)
        result->glic_actor_feature_enabled = input.glic_actor_feature_enabled();
      if (success)
        result->glic_rollout_feature_enabled = input.glic_rollout_feature_enabled();
      if (success)
        result->glic_tiered_rollout_feature_enabled = input.glic_tiered_rollout_feature_enabled();
      if (success)
        result->glic_tiered_rollout_v2_feature_enabled = input.glic_tiered_rollout_v2_feature_enabled();
      if (success && !input.ReadPlatform(&result->platform))
        success = false;
      if (success && !input.ReadFormFactor(&result->form_factor))
        success = false;
      if (success && !input.ReadBooleanSettings(&result->boolean_settings))
        success = false;
      if (success && !input.ReadHotkey(&result->hotkey))
        success = false;
      if (success && !input.ReadLocale(&result->locale))
        success = false;
      if (success && !input.ReadPermanentCountryCode(&result->permanent_country_code))
        success = false;
      if (success && !input.ReadSessionCountryCode(&result->session_country_code))
        success = false;
      if (success)
        result->system_requirement_met = input.system_requirement_met();
      if (success)
        result->os_version_supported = input.os_version_supported();
      if (success)
        result->anchor_entrypoint_override_active = input.anchor_entrypoint_override_active();
      if (success)
        result->primary_account_needs_signed_in = input.primary_account_needs_signed_in();
      if (success && !input.ReadDogfoodStatus(&result->dogfood_status))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::ScreenshotTestKeyConfiguration::DataView, ::glic::mojom::ScreenshotTestKeyConfigurationPtr>::Read(
    ::glic::mojom::ScreenshotTestKeyConfiguration::DataView input,
    ::glic::mojom::ScreenshotTestKeyConfigurationPtr* output) {
  bool success = true;
  ::glic::mojom::ScreenshotTestKeyConfigurationPtr result(::glic::mojom::ScreenshotTestKeyConfiguration::New());
  
      if (success && !input.ReadPublicKey(&result->public_key))
        success = false;
      if (success && !input.ReadAuthSecret(&result->auth_secret))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::glic::mojom::TriggerInvokeFromInternalsOptions::DataView, ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr>::Read(
    ::glic::mojom::TriggerInvokeFromInternalsOptions::DataView input,
    ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr* output) {
  bool success = true;
  ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr result(::glic::mojom::TriggerInvokeFromInternalsOptions::New());
  
      if (success && !input.ReadInvocationSource(&result->invocation_source))
        success = false;
      if (success && !input.ReadPrompts(&result->prompts))
        success = false;
      if (success && !input.ReadAdditionalContext(&result->additional_context))
        success = false;
      if (success && !input.ReadConversation(&result->conversation))
        success = false;
      if (success && !input.ReadFeatureMode(&result->feature_mode)) {
        success = false;
      }
      if (success)
        result->disable_zss = input.disable_zss();
      if (success && !input.ReadZssConfig(&result->zss_config))
        success = false;
      if (success && !input.ReadSkillId(&result->skill_id))
        success = false;
      if (success && !input.ReadErrorMessage(&result->error_message))
        success = false;
      if (success && !input.ReadTimeout(&result->timeout))
        success = false;
      if (success)
        result->auto_submit = input.auto_submit();
      if (success && !input.ReadFreOverride(&result->fre_override))
        success = false;
      if (success)
        result->wait_for_panel_open = input.wait_for_panel_open();
      if (success) {
        result->focus_on_show = input.focus_on_show();
      }
      if (success && !input.ReadFreCompletionWaitMode(&result->fre_completion_wait_mode))
        success = false;
      if (success) {
        result->show_panel = input.show_panel();
      }
      if (success && !input.ReadSurface(&result->surface))
        success = false;
      if (success) {
        result->specific_tab_index = input.specific_tab_index();
      }
      if (success && !input.ReadSpecificTabsToShareIndices(&result->specific_tabs_to_share_indices))
        success = false;
      if (success && !input.ReadActuationTarget(&result->actuation_target))
        success = false;
      if (success && !input.ReadPayload(&result->payload))
        success = false;
      if (success)
        result->take_screenshot = input.take_screenshot();
      if (success && !input.ReadKeyConfig(&result->key_config))
        success = false;
      if (success)
        result->supersede_if_in_progress = input.supersede_if_in_progress();
  *output = std::move(result);
  return success;
}

}  // 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 InternalsPageHandlerInterceptorForTesting::GetInternalsDataPayload(GetInternalsDataPayloadCallback callback) {
  GetForwardingInterface()->GetInternalsDataPayload(std::move(callback));
}
void InternalsPageHandlerInterceptorForTesting::SetGuestUrlPresets(const ::GURL& autopush, const ::GURL& staging, const ::GURL& preprod, const ::GURL& prod) {
  GetForwardingInterface()->SetGuestUrlPresets(
    std::move(autopush)
    , 
    std::move(staging)
    , 
    std::move(preprod)
    , 
    std::move(prod)
    );
}
void InternalsPageHandlerInterceptorForTesting::TriggerInvokeFromInternalsAction(TriggerInvokeFromInternalsOptionsPtr options, TriggerInvokeFromInternalsActionCallback callback) {
  GetForwardingInterface()->TriggerInvokeFromInternalsAction(
    std::move(options)
    , std::move(callback));
}
void InternalsPageHandlerInterceptorForTesting::GetOpenTabs(GetOpenTabsCallback callback) {
  GetForwardingInterface()->GetOpenTabs(std::move(callback));
}
void InternalsPageHandlerInterceptorForTesting::SetWebContinuityOriginatingHostUrlPreset(const ::GURL& web_continuity_originating_host_url) {
  GetForwardingInterface()->SetWebContinuityOriginatingHostUrlPreset(
    std::move(web_continuity_originating_host_url)
    );
}
void InternalsPageHandlerInterceptorForTesting::SetShowErrorAllowed(bool allowed) {
  GetForwardingInterface()->SetShowErrorAllowed(
    std::move(allowed)
    );
}
void InternalsPageHandlerInterceptorForTesting::ShowExperimentalOptIn() {
  GetForwardingInterface()->ShowExperimentalOptIn();
}
void InternalsPageHandlerInterceptorForTesting::RevokeExperimentalTriggeringConsent() {
  GetForwardingInterface()->RevokeExperimentalTriggeringConsent();
}
void InternalsPageHandlerInterceptorForTesting::RevokeGlicConsent() {
  GetForwardingInterface()->RevokeGlicConsent();
}
void InternalsPageHandlerInterceptorForTesting::RevokeActuationConsent() {
  GetForwardingInterface()->RevokeActuationConsent();
}
InternalsPageHandlerAsyncWaiter::InternalsPageHandlerAsyncWaiter(
    InternalsPageHandler* proxy) : proxy_(proxy) {}

InternalsPageHandlerAsyncWaiter::~InternalsPageHandlerAsyncWaiter() = default;


void InternalsPageHandlerAsyncWaiter::GetInternalsDataPayload(
    InternalsDataPayloadPtr* out_internals_data) {
  base::RunLoop loop;
  proxy_->GetInternalsDataPayload(
      base::BindOnce(
          [](base::RunLoop* loop,
             InternalsDataPayloadPtr* out_internals_data
,
             InternalsDataPayloadPtr internals_data) {*out_internals_data = std::move(internals_data);
            loop->Quit();
          },
          &loop,
          out_internals_data));
  loop.Run();
}

InternalsDataPayloadPtr InternalsPageHandlerAsyncWaiter::GetInternalsDataPayload(
    ) {
  InternalsDataPayloadPtr async_wait_result;
  GetInternalsDataPayload(&async_wait_result);
  return async_wait_result;
}

void InternalsPageHandlerAsyncWaiter::TriggerInvokeFromInternalsAction(
    TriggerInvokeFromInternalsOptionsPtr options, bool* out_success, std::string* out_error_message) {
  base::RunLoop loop;
  proxy_->TriggerInvokeFromInternalsAction(
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             std::string* out_error_message
,
             bool success,
             const std::string& error_message) {*out_success = std::move(success);*out_error_message = std::move(error_message);
            loop->Quit();
          },
          &loop,
          out_success,
          out_error_message));
  loop.Run();
}



void InternalsPageHandlerAsyncWaiter::GetOpenTabs(
    std::vector<std::string>* out_tab_titles) {
  base::RunLoop loop;
  proxy_->GetOpenTabs(
      base::BindOnce(
          [](base::RunLoop* loop,
             std::vector<std::string>* out_tab_titles
,
             const std::vector<std::string>& tab_titles) {*out_tab_titles = std::move(tab_titles);
            loop->Quit();
          },
          &loop,
          out_tab_titles));
  loop.Run();
}

std::vector<std::string> InternalsPageHandlerAsyncWaiter::GetOpenTabs(
    ) {
  std::vector<std::string> async_wait_result;
  GetOpenTabs(&async_wait_result);
  return async_wait_result;
}




void InternalsPageHandlerFactoryInterceptorForTesting::CreateInternalsPageHandler(::mojo::PendingReceiver<InternalsPageHandler> receiver) {
  GetForwardingInterface()->CreateInternalsPageHandler(
    std::move(receiver)
    );
}
InternalsPageHandlerFactoryAsyncWaiter::InternalsPageHandlerFactoryAsyncWaiter(
    InternalsPageHandlerFactory* proxy) : proxy_(proxy) {}

InternalsPageHandlerFactoryAsyncWaiter::~InternalsPageHandlerFactoryAsyncWaiter() = default;







}  // glic::mojom


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