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

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


namespace contextual_tasks::mojom {
InjectedInput::InjectedInput()
    : title(),
      thumbnail(),
      icon_id(),
      file_token(),
      supports_unimodal(),
      query_text(),
      submit_after_injection() {}

InjectedInput::InjectedInput(
    const std::optional<std::string>& title_in,
    const std::optional<std::string>& thumbnail_in,
    IconType icon_id_in,
    const std::optional<::base::UnguessableToken>& file_token_in,
    bool supports_unimodal_in,
    const std::optional<std::string>& query_text_in,
    bool submit_after_injection_in)
    : title(std::move(title_in)),
      thumbnail(std::move(thumbnail_in)),
      icon_id(std::move(icon_id_in)),
      file_token(std::move(file_token_in)),
      supports_unimodal(std::move(supports_unimodal_in)),
      query_text(std::move(query_text_in)),
      submit_after_injection(std::move(submit_after_injection_in)) {}

InjectedInput::~InjectedInput() = default;

void InjectedInput::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "title"), this->title,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "thumbnail"), this->thumbnail,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "icon_id"), this->icon_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type IconType>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "file_token"), this->file_token,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::base::UnguessableToken>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "supports_unimodal"), this->supports_unimodal,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "query_text"), this->query_text,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "submit_after_injection"), this->submit_after_injection,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

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

ContextualTaskId::ContextualTaskId(
    const ::base::Uuid& value_in)
    : value(std::move(value_in)) {}

ContextualTaskId::~ContextualTaskId() = default;

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

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

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

ContextualWindowId::~ContextualWindowId() = default;

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

bool ContextualWindowId::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TabContext::TabContext()
    : url(),
      title(),
      tab_id(),
      has_chrome_tab_data() {}

TabContext::TabContext(
    const ::GURL& url_in,
    const std::string& title_in,
    int32_t tab_id_in,
    bool has_chrome_tab_data_in)
    : url(std::move(url_in)),
      title(std::move(title_in)),
      tab_id(std::move(tab_id_in)),
      has_chrome_tab_data(std::move(has_chrome_tab_data_in)) {}

TabContext::~TabContext() = default;

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

bool TabContext::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ImageContext::ImageContext()
    : url(),
      title() {}

ImageContext::ImageContext(
    const ::GURL& url_in,
    const std::string& title_in)
    : url(std::move(url_in)),
      title(std::move(title_in)) {}

ImageContext::~ImageContext() = default;

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

bool ImageContext::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
FileContext::FileContext()
    : url(),
      title() {}

FileContext::FileContext(
    const ::GURL& url_in,
    const std::string& title_in)
    : url(std::move(url_in)),
      title(std::move(title_in)) {}

FileContext::~FileContext() = default;

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

bool FileContext::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ComposeboxPosition::ComposeboxPosition()
    : max_width(),
      max_height(),
      margin_bottom(),
      margin_left() {}

ComposeboxPosition::ComposeboxPosition(
    std::optional<uint32_t> max_width_in,
    std::optional<uint32_t> max_height_in,
    std::optional<int32_t> margin_bottom_in,
    std::optional<int32_t> margin_left_in)
    : max_width(std::move(max_width_in)),
      max_height(std::move(max_height_in)),
      margin_bottom(std::move(margin_bottom_in)),
      margin_left(std::move(margin_left_in)) {}

ComposeboxPosition::~ComposeboxPosition() = default;

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

bool ComposeboxPosition::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ContextInfoPtr
ContextInfo::NewTab(
    TabContextPtr value) {
  return ContextInfoPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kTab)>,
      std::move(value));
}

ContextInfoPtr
ContextInfo::NewImage(
    ImageContextPtr value) {
  return ContextInfoPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kImage)>,
      std::move(value));
}

ContextInfoPtr
ContextInfo::NewFile(
    FileContextPtr value) {
  return ContextInfoPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFile)>,
      std::move(value));
}

ContextInfo::ContextInfo(
    std::in_place_index_t<static_cast<size_t>(Tag::kTab)>,
    TabContextPtr value)
    : tag_(Tag::kTab),
      data_(std::in_place_index<static_cast<size_t>(Tag::kTab)>,
            std::move(value)) {}

ContextInfo::ContextInfo(
    std::in_place_index_t<static_cast<size_t>(Tag::kImage)>,
    ImageContextPtr value)
    : tag_(Tag::kImage),
      data_(std::in_place_index<static_cast<size_t>(Tag::kImage)>,
            std::move(value)) {}

ContextInfo::ContextInfo(
    std::in_place_index_t<static_cast<size_t>(Tag::kFile)>,
    FileContextPtr value)
    : tag_(Tag::kFile),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFile)>,
            std::move(value)) {}
ContextInfo::~ContextInfo() {
  DestroyActive();
}

void ContextInfo::set_tab(TabContextPtr tab) {
  if (tag_ == Tag::kTab) {
    data_.tab = std::move(tab);
  } else {
    DestroyActive();
    tag_ = Tag::kTab;
    new (&data_.tab) TabContextPtr(
        std::move(tab));
  }
}

void ContextInfo::set_image(ImageContextPtr image) {
  if (tag_ == Tag::kImage) {
    data_.image = std::move(image);
  } else {
    DestroyActive();
    tag_ = Tag::kImage;
    new (&data_.image) ImageContextPtr(
        std::move(image));
  }
}

void ContextInfo::set_file(FileContextPtr file) {
  if (tag_ == Tag::kFile) {
    data_.file = std::move(file);
  } else {
    DestroyActive();
    tag_ = Tag::kFile;
    new (&data_.file) FileContextPtr(
        std::move(file));
  }
}


ContextInfo::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kTab)>,
    TabContextPtr value)
    : tab(std::move(value)) {}

ContextInfo::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kImage)>,
    ImageContextPtr value)
    : image(std::move(value)) {}

ContextInfo::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFile)>,
    FileContextPtr value)
    : file(std::move(value)) {}

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

    case Tag::kTab:
      std::destroy_at(&data_.tab);
      break;
    case Tag::kImage:
      std::destroy_at(&data_.image);
      break;
    case Tag::kFile:
      std::destroy_at(&data_.file);
      break;
  }
}

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

PageHandler::IPCStableHashFunction PageHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::PageHandler>(message.name())) {
    case messages::PageHandler::kGetThreadUrl: {
      return &PageHandler::GetThreadUrl_Sym::IPCStableHash;
    }
    case messages::PageHandler::kGetUrlForTask: {
      return &PageHandler::GetUrlForTask_Sym::IPCStableHash;
    }
    case messages::PageHandler::kSetTaskId: {
      return &PageHandler::SetTaskId_Sym::IPCStableHash;
    }
    case messages::PageHandler::kIsZeroState: {
      return &PageHandler::IsZeroState_Sym::IPCStableHash;
    }
    case messages::PageHandler::kIsAiPage: {
      return &PageHandler::IsAiPage_Sym::IPCStableHash;
    }
    case messages::PageHandler::kIsPendingErrorPage: {
      return &PageHandler::IsPendingErrorPage_Sym::IPCStableHash;
    }
    case messages::PageHandler::kIsEmbeddedPageErrorDocument: {
      return &PageHandler::IsEmbeddedPageErrorDocument_Sym::IPCStableHash;
    }
    case messages::PageHandler::kSetThreadTitle: {
      return &PageHandler::SetThreadTitle_Sym::IPCStableHash;
    }
    case messages::PageHandler::kCloseSidePanel: {
      return &PageHandler::CloseSidePanel_Sym::IPCStableHash;
    }
    case messages::PageHandler::kShowThreadHistory: {
      return &PageHandler::ShowThreadHistory_Sym::IPCStableHash;
    }
    case messages::PageHandler::kIsShownInTab: {
      return &PageHandler::IsShownInTab_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOpenMyActivityUi: {
      return &PageHandler::OpenMyActivityUi_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOpenFeedbackUi: {
      return &PageHandler::OpenFeedbackUi_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOpenOnboardingHelpUi: {
      return &PageHandler::OpenOnboardingHelpUi_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOpenOverflowMenuHelpUi: {
      return &PageHandler::OpenOverflowMenuHelpUi_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOpenUrl: {
      return &PageHandler::OpenUrl_Sym::IPCStableHash;
    }
    case messages::PageHandler::kMoveTaskUiToNewTab: {
      return &PageHandler::MoveTaskUiToNewTab_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnTabClickedFromSourcesMenu: {
      return &PageHandler::OnTabClickedFromSourcesMenu_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnFileClickedFromSourcesMenu: {
      return &PageHandler::OnFileClickedFromSourcesMenu_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnImageClickedFromSourcesMenu: {
      return &PageHandler::OnImageClickedFromSourcesMenu_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnWebviewMessage: {
      return &PageHandler::OnWebviewMessage_Sym::IPCStableHash;
    }
    case messages::PageHandler::kGetCommonSearchParams: {
      return &PageHandler::GetCommonSearchParams_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnboardingTooltipDismissed: {
      return &PageHandler::OnboardingTooltipDismissed_Sym::IPCStableHash;
    }
    case messages::PageHandler::kLensSearchTooltipDismissed: {
      return &PageHandler::LensSearchTooltipDismissed_Sym::IPCStableHash;
    }
    case messages::PageHandler::kAskGTooltipDismissed: {
      return &PageHandler::AskGTooltipDismissed_Sym::IPCStableHash;
    }
    case messages::PageHandler::kReopenTabs: {
      return &PageHandler::ReopenTabs_Sym::IPCStableHash;
    }
    case messages::PageHandler::kPinSidePanel: {
      return &PageHandler::PinSidePanel_Sym::IPCStableHash;
    }
    case messages::PageHandler::kUnpinSidePanel: {
      return &PageHandler::UnpinSidePanel_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnContextMenuOpened: {
      return &PageHandler::OnContextMenuOpened_Sym::IPCStableHash;
    }
    case messages::PageHandler::kNotifySmartTabSharingTryItIphResult: {
      return &PageHandler::NotifySmartTabSharingTryItIphResult_Sym::IPCStableHash;
    }
    case messages::PageHandler::kNotifySmartTabSharingDefaultOnIphResult: {
      return &PageHandler::NotifySmartTabSharingDefaultOnIphResult_Sym::IPCStableHash;
    }
    case messages::PageHandler::kRegisterWindow: {
      return &PageHandler::RegisterWindow_Sym::IPCStableHash;
    }
    case messages::PageHandler::kCloseWindow: {
      return &PageHandler::CloseWindow_Sym::IPCStableHash;
    }
    case messages::PageHandler::kMaybeTriggerPinningPromo: {
      return &PageHandler::MaybeTriggerPinningPromo_Sym::IPCStableHash;
    }
    case messages::PageHandler::kShowPageInfoBubble: {
      return &PageHandler::ShowPageInfoBubble_Sym::IPCStableHash;
    }
    case messages::PageHandler::kOnLogoPointerDown: {
      return &PageHandler::OnLogoPointerDown_Sym::IPCStableHash;
    }
    case messages::PageHandler::kCreateNewThread: {
      return &PageHandler::CreateNewThread_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* PageHandler::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::PageHandler>(message.name())) {
      case messages::PageHandler::kGetThreadUrl:
            return "Receive contextual_tasks::mojom::PageHandler::GetThreadUrl";
      case messages::PageHandler::kGetUrlForTask:
            return "Receive contextual_tasks::mojom::PageHandler::GetUrlForTask";
      case messages::PageHandler::kSetTaskId:
            return "Receive contextual_tasks::mojom::PageHandler::SetTaskId";
      case messages::PageHandler::kIsZeroState:
            return "Receive contextual_tasks::mojom::PageHandler::IsZeroState";
      case messages::PageHandler::kIsAiPage:
            return "Receive contextual_tasks::mojom::PageHandler::IsAiPage";
      case messages::PageHandler::kIsPendingErrorPage:
            return "Receive contextual_tasks::mojom::PageHandler::IsPendingErrorPage";
      case messages::PageHandler::kIsEmbeddedPageErrorDocument:
            return "Receive contextual_tasks::mojom::PageHandler::IsEmbeddedPageErrorDocument";
      case messages::PageHandler::kSetThreadTitle:
            return "Receive contextual_tasks::mojom::PageHandler::SetThreadTitle";
      case messages::PageHandler::kCloseSidePanel:
            return "Receive contextual_tasks::mojom::PageHandler::CloseSidePanel";
      case messages::PageHandler::kShowThreadHistory:
            return "Receive contextual_tasks::mojom::PageHandler::ShowThreadHistory";
      case messages::PageHandler::kIsShownInTab:
            return "Receive contextual_tasks::mojom::PageHandler::IsShownInTab";
      case messages::PageHandler::kOpenMyActivityUi:
            return "Receive contextual_tasks::mojom::PageHandler::OpenMyActivityUi";
      case messages::PageHandler::kOpenFeedbackUi:
            return "Receive contextual_tasks::mojom::PageHandler::OpenFeedbackUi";
      case messages::PageHandler::kOpenOnboardingHelpUi:
            return "Receive contextual_tasks::mojom::PageHandler::OpenOnboardingHelpUi";
      case messages::PageHandler::kOpenOverflowMenuHelpUi:
            return "Receive contextual_tasks::mojom::PageHandler::OpenOverflowMenuHelpUi";
      case messages::PageHandler::kOpenUrl:
            return "Receive contextual_tasks::mojom::PageHandler::OpenUrl";
      case messages::PageHandler::kMoveTaskUiToNewTab:
            return "Receive contextual_tasks::mojom::PageHandler::MoveTaskUiToNewTab";
      case messages::PageHandler::kOnTabClickedFromSourcesMenu:
            return "Receive contextual_tasks::mojom::PageHandler::OnTabClickedFromSourcesMenu";
      case messages::PageHandler::kOnFileClickedFromSourcesMenu:
            return "Receive contextual_tasks::mojom::PageHandler::OnFileClickedFromSourcesMenu";
      case messages::PageHandler::kOnImageClickedFromSourcesMenu:
            return "Receive contextual_tasks::mojom::PageHandler::OnImageClickedFromSourcesMenu";
      case messages::PageHandler::kOnWebviewMessage:
            return "Receive contextual_tasks::mojom::PageHandler::OnWebviewMessage";
      case messages::PageHandler::kGetCommonSearchParams:
            return "Receive contextual_tasks::mojom::PageHandler::GetCommonSearchParams";
      case messages::PageHandler::kOnboardingTooltipDismissed:
            return "Receive contextual_tasks::mojom::PageHandler::OnboardingTooltipDismissed";
      case messages::PageHandler::kLensSearchTooltipDismissed:
            return "Receive contextual_tasks::mojom::PageHandler::LensSearchTooltipDismissed";
      case messages::PageHandler::kAskGTooltipDismissed:
            return "Receive contextual_tasks::mojom::PageHandler::AskGTooltipDismissed";
      case messages::PageHandler::kReopenTabs:
            return "Receive contextual_tasks::mojom::PageHandler::ReopenTabs";
      case messages::PageHandler::kPinSidePanel:
            return "Receive contextual_tasks::mojom::PageHandler::PinSidePanel";
      case messages::PageHandler::kUnpinSidePanel:
            return "Receive contextual_tasks::mojom::PageHandler::UnpinSidePanel";
      case messages::PageHandler::kOnContextMenuOpened:
            return "Receive contextual_tasks::mojom::PageHandler::OnContextMenuOpened";
      case messages::PageHandler::kNotifySmartTabSharingTryItIphResult:
            return "Receive contextual_tasks::mojom::PageHandler::NotifySmartTabSharingTryItIphResult";
      case messages::PageHandler::kNotifySmartTabSharingDefaultOnIphResult:
            return "Receive contextual_tasks::mojom::PageHandler::NotifySmartTabSharingDefaultOnIphResult";
      case messages::PageHandler::kRegisterWindow:
            return "Receive contextual_tasks::mojom::PageHandler::RegisterWindow";
      case messages::PageHandler::kCloseWindow:
            return "Receive contextual_tasks::mojom::PageHandler::CloseWindow";
      case messages::PageHandler::kMaybeTriggerPinningPromo:
            return "Receive contextual_tasks::mojom::PageHandler::MaybeTriggerPinningPromo";
      case messages::PageHandler::kShowPageInfoBubble:
            return "Receive contextual_tasks::mojom::PageHandler::ShowPageInfoBubble";
      case messages::PageHandler::kOnLogoPointerDown:
            return "Receive contextual_tasks::mojom::PageHandler::OnLogoPointerDown";
      case messages::PageHandler::kCreateNewThread:
            return "Receive contextual_tasks::mojom::PageHandler::CreateNewThread";
    }
  } else {
    switch (static_cast<messages::PageHandler>(message.name())) {
      case messages::PageHandler::kGetThreadUrl:
            return "Receive reply contextual_tasks::mojom::PageHandler::GetThreadUrl";
      case messages::PageHandler::kGetUrlForTask:
            return "Receive reply contextual_tasks::mojom::PageHandler::GetUrlForTask";
      case messages::PageHandler::kSetTaskId:
            return "Receive reply contextual_tasks::mojom::PageHandler::SetTaskId";
      case messages::PageHandler::kIsZeroState:
            return "Receive reply contextual_tasks::mojom::PageHandler::IsZeroState";
      case messages::PageHandler::kIsAiPage:
            return "Receive reply contextual_tasks::mojom::PageHandler::IsAiPage";
      case messages::PageHandler::kIsPendingErrorPage:
            return "Receive reply contextual_tasks::mojom::PageHandler::IsPendingErrorPage";
      case messages::PageHandler::kIsEmbeddedPageErrorDocument:
            return "Receive reply contextual_tasks::mojom::PageHandler::IsEmbeddedPageErrorDocument";
      case messages::PageHandler::kSetThreadTitle:
            return "Receive reply contextual_tasks::mojom::PageHandler::SetThreadTitle";
      case messages::PageHandler::kCloseSidePanel:
            return "Receive reply contextual_tasks::mojom::PageHandler::CloseSidePanel";
      case messages::PageHandler::kShowThreadHistory:
            return "Receive reply contextual_tasks::mojom::PageHandler::ShowThreadHistory";
      case messages::PageHandler::kIsShownInTab:
            return "Receive reply contextual_tasks::mojom::PageHandler::IsShownInTab";
      case messages::PageHandler::kOpenMyActivityUi:
            return "Receive reply contextual_tasks::mojom::PageHandler::OpenMyActivityUi";
      case messages::PageHandler::kOpenFeedbackUi:
            return "Receive reply contextual_tasks::mojom::PageHandler::OpenFeedbackUi";
      case messages::PageHandler::kOpenOnboardingHelpUi:
            return "Receive reply contextual_tasks::mojom::PageHandler::OpenOnboardingHelpUi";
      case messages::PageHandler::kOpenOverflowMenuHelpUi:
            return "Receive reply contextual_tasks::mojom::PageHandler::OpenOverflowMenuHelpUi";
      case messages::PageHandler::kOpenUrl:
            return "Receive reply contextual_tasks::mojom::PageHandler::OpenUrl";
      case messages::PageHandler::kMoveTaskUiToNewTab:
            return "Receive reply contextual_tasks::mojom::PageHandler::MoveTaskUiToNewTab";
      case messages::PageHandler::kOnTabClickedFromSourcesMenu:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnTabClickedFromSourcesMenu";
      case messages::PageHandler::kOnFileClickedFromSourcesMenu:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnFileClickedFromSourcesMenu";
      case messages::PageHandler::kOnImageClickedFromSourcesMenu:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnImageClickedFromSourcesMenu";
      case messages::PageHandler::kOnWebviewMessage:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnWebviewMessage";
      case messages::PageHandler::kGetCommonSearchParams:
            return "Receive reply contextual_tasks::mojom::PageHandler::GetCommonSearchParams";
      case messages::PageHandler::kOnboardingTooltipDismissed:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnboardingTooltipDismissed";
      case messages::PageHandler::kLensSearchTooltipDismissed:
            return "Receive reply contextual_tasks::mojom::PageHandler::LensSearchTooltipDismissed";
      case messages::PageHandler::kAskGTooltipDismissed:
            return "Receive reply contextual_tasks::mojom::PageHandler::AskGTooltipDismissed";
      case messages::PageHandler::kReopenTabs:
            return "Receive reply contextual_tasks::mojom::PageHandler::ReopenTabs";
      case messages::PageHandler::kPinSidePanel:
            return "Receive reply contextual_tasks::mojom::PageHandler::PinSidePanel";
      case messages::PageHandler::kUnpinSidePanel:
            return "Receive reply contextual_tasks::mojom::PageHandler::UnpinSidePanel";
      case messages::PageHandler::kOnContextMenuOpened:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnContextMenuOpened";
      case messages::PageHandler::kNotifySmartTabSharingTryItIphResult:
            return "Receive reply contextual_tasks::mojom::PageHandler::NotifySmartTabSharingTryItIphResult";
      case messages::PageHandler::kNotifySmartTabSharingDefaultOnIphResult:
            return "Receive reply contextual_tasks::mojom::PageHandler::NotifySmartTabSharingDefaultOnIphResult";
      case messages::PageHandler::kRegisterWindow:
            return "Receive reply contextual_tasks::mojom::PageHandler::RegisterWindow";
      case messages::PageHandler::kCloseWindow:
            return "Receive reply contextual_tasks::mojom::PageHandler::CloseWindow";
      case messages::PageHandler::kMaybeTriggerPinningPromo:
            return "Receive reply contextual_tasks::mojom::PageHandler::MaybeTriggerPinningPromo";
      case messages::PageHandler::kShowPageInfoBubble:
            return "Receive reply contextual_tasks::mojom::PageHandler::ShowPageInfoBubble";
      case messages::PageHandler::kOnLogoPointerDown:
            return "Receive reply contextual_tasks::mojom::PageHandler::OnLogoPointerDown";
      case messages::PageHandler::kCreateNewThread:
            return "Receive reply contextual_tasks::mojom::PageHandler::CreateNewThread";
    }
  }
  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 PageHandler::GetThreadUrl_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 = 0x14e76521;  // IPCStableHash for contextual_tasks::mojom::PageHandler::GetThreadUrl
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::GetUrlForTask_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 = 0x0bb5cb5d;  // IPCStableHash for contextual_tasks::mojom::PageHandler::GetUrlForTask
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::SetTaskId_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 = 0x4abb3dd0;  // IPCStableHash for contextual_tasks::mojom::PageHandler::SetTaskId
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::IsZeroState_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 = 0x8e67bc63;  // IPCStableHash for contextual_tasks::mojom::PageHandler::IsZeroState
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::IsAiPage_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 = 0x27a94d1f;  // IPCStableHash for contextual_tasks::mojom::PageHandler::IsAiPage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::IsPendingErrorPage_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 = 0x0b5f0d95;  // IPCStableHash for contextual_tasks::mojom::PageHandler::IsPendingErrorPage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::IsEmbeddedPageErrorDocument_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 = 0xf5d9d758;  // IPCStableHash for contextual_tasks::mojom::PageHandler::IsEmbeddedPageErrorDocument
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::SetThreadTitle_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 = 0x61a3ee99;  // IPCStableHash for contextual_tasks::mojom::PageHandler::SetThreadTitle
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::CloseSidePanel_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 = 0x5263a2b0;  // IPCStableHash for contextual_tasks::mojom::PageHandler::CloseSidePanel
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::ShowThreadHistory_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 = 0xb7b2acad;  // IPCStableHash for contextual_tasks::mojom::PageHandler::ShowThreadHistory
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::IsShownInTab_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 = 0x5b4988a6;  // IPCStableHash for contextual_tasks::mojom::PageHandler::IsShownInTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OpenMyActivityUi_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 = 0xfb7f41f8;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OpenMyActivityUi
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OpenFeedbackUi_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 = 0xa616e789;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OpenFeedbackUi
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OpenOnboardingHelpUi_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 = 0xfc4bd320;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OpenOnboardingHelpUi
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OpenOverflowMenuHelpUi_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 = 0x5d84b870;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OpenOverflowMenuHelpUi
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OpenUrl_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 = 0x2423aa37;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OpenUrl
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::MoveTaskUiToNewTab_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 = 0x566627e0;  // IPCStableHash for contextual_tasks::mojom::PageHandler::MoveTaskUiToNewTab
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnTabClickedFromSourcesMenu_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 = 0xa06acd21;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnTabClickedFromSourcesMenu
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnFileClickedFromSourcesMenu_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 = 0x08b1d364;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnFileClickedFromSourcesMenu
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnImageClickedFromSourcesMenu_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 = 0xec5bcd66;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnImageClickedFromSourcesMenu
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnWebviewMessage_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 = 0x79e8c3a4;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnWebviewMessage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::GetCommonSearchParams_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 = 0x65baa556;  // IPCStableHash for contextual_tasks::mojom::PageHandler::GetCommonSearchParams
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnboardingTooltipDismissed_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 = 0xa1bde737;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnboardingTooltipDismissed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::LensSearchTooltipDismissed_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 = 0x181f2f1b;  // IPCStableHash for contextual_tasks::mojom::PageHandler::LensSearchTooltipDismissed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::AskGTooltipDismissed_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 = 0xb3c15800;  // IPCStableHash for contextual_tasks::mojom::PageHandler::AskGTooltipDismissed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::ReopenTabs_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 = 0x8d8d1018;  // IPCStableHash for contextual_tasks::mojom::PageHandler::ReopenTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::PinSidePanel_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 = 0x911e368b;  // IPCStableHash for contextual_tasks::mojom::PageHandler::PinSidePanel
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::UnpinSidePanel_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 = 0x92095530;  // IPCStableHash for contextual_tasks::mojom::PageHandler::UnpinSidePanel
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnContextMenuOpened_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 = 0x1ead79ca;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnContextMenuOpened
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::NotifySmartTabSharingTryItIphResult_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 = 0xbf203d99;  // IPCStableHash for contextual_tasks::mojom::PageHandler::NotifySmartTabSharingTryItIphResult
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::NotifySmartTabSharingDefaultOnIphResult_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 = 0xd66391f4;  // IPCStableHash for contextual_tasks::mojom::PageHandler::NotifySmartTabSharingDefaultOnIphResult
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::RegisterWindow_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 = 0x8b4fbb60;  // IPCStableHash for contextual_tasks::mojom::PageHandler::RegisterWindow
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::CloseWindow_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 = 0x995ae4ef;  // IPCStableHash for contextual_tasks::mojom::PageHandler::CloseWindow
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::MaybeTriggerPinningPromo_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 = 0xdbaafd03;  // IPCStableHash for contextual_tasks::mojom::PageHandler::MaybeTriggerPinningPromo
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::ShowPageInfoBubble_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 = 0xe53d86f1;  // IPCStableHash for contextual_tasks::mojom::PageHandler::ShowPageInfoBubble
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::OnLogoPointerDown_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 = 0xfce6811b;  // IPCStableHash for contextual_tasks::mojom::PageHandler::OnLogoPointerDown
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t PageHandler::CreateNewThread_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 = 0x76e691e1;  // IPCStableHash for contextual_tasks::mojom::PageHandler::CreateNewThread
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class PageHandler_GetThreadUrl_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_GetThreadUrl_ForwardToCallback(
      PageHandler::GetThreadUrlCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::GetThreadUrlCallback callback_;
};

class PageHandler_GetUrlForTask_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_GetUrlForTask_ForwardToCallback(
      PageHandler::GetUrlForTaskCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::GetUrlForTaskCallback callback_;
};

class PageHandler_IsZeroState_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_IsZeroState_ForwardToCallback(
      PageHandler::IsZeroStateCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::IsZeroStateCallback callback_;
};

class PageHandler_IsAiPage_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_IsAiPage_ForwardToCallback(
      PageHandler::IsAiPageCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::IsAiPageCallback callback_;
};

class PageHandler_IsPendingErrorPage_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_IsPendingErrorPage_ForwardToCallback(
      PageHandler::IsPendingErrorPageCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::IsPendingErrorPageCallback callback_;
};

class PageHandler_IsEmbeddedPageErrorDocument_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_IsEmbeddedPageErrorDocument_ForwardToCallback(
      PageHandler::IsEmbeddedPageErrorDocumentCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::IsEmbeddedPageErrorDocumentCallback callback_;
};

class PageHandler_IsShownInTab_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_IsShownInTab_ForwardToCallback(
      PageHandler::IsShownInTabCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::IsShownInTabCallback callback_;
};

class PageHandler_GetCommonSearchParams_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  PageHandler_GetCommonSearchParams_ForwardToCallback(
      PageHandler::GetCommonSearchParamsCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  PageHandler::GetCommonSearchParamsCallback callback_;
};

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

void PageHandlerProxy::GetThreadUrl(
    GetThreadUrlCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::GetThreadUrl");
#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::PageHandler::kGetThreadUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_GetThreadUrl_Params_Data> params(
          message);
  params.Allocate();

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

void PageHandlerProxy::GetUrlForTask(
    const ::base::Uuid& in_uuid, GetUrlForTaskCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::GetUrlForTask", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("uuid"), in_uuid,
                        "<value of type const ::base::Uuid&>");
   });
#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::PageHandler::kGetUrlForTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_GetUrlForTask_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->uuid)::BaseType> uuid_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_uuid,
    uuid_fragment);

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

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

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

void PageHandlerProxy::SetTaskId(
    const ::base::Uuid& in_uuid) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::SetTaskId", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("uuid"), in_uuid,
                        "<value of type const ::base::Uuid&>");
   });
#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::PageHandler::kSetTaskId), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_SetTaskId_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->uuid)::BaseType> uuid_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_uuid,
    uuid_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("SetTaskId");
#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 PageHandlerProxy::IsZeroState(
    const ::GURL& in_url, IsZeroStateCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::IsZeroState", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
   });
#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::PageHandler::kIsZeroState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsZeroState_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

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

void PageHandlerProxy::IsAiPage(
    const ::GURL& in_url, IsAiPageCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::IsAiPage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
   });
#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::PageHandler::kIsAiPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsAiPage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

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

void PageHandlerProxy::IsPendingErrorPage(
    const ::base::Uuid& in_task_id, IsPendingErrorPageCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::IsPendingErrorPage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type const ::base::Uuid&>");
   });
#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::PageHandler::kIsPendingErrorPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsPendingErrorPage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->task_id)::BaseType> task_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_task_id,
    task_id_fragment);

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

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

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

void PageHandlerProxy::IsEmbeddedPageErrorDocument(
    IsEmbeddedPageErrorDocumentCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::IsEmbeddedPageErrorDocument");
#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::PageHandler::kIsEmbeddedPageErrorDocument), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsEmbeddedPageErrorDocument_Params_Data> params(
          message);
  params.Allocate();

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

void PageHandlerProxy::SetThreadTitle(
    const std::string& in_title) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::SetThreadTitle", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("title"), in_title,
                        "<value of type const std::string&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kSetThreadTitle), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_SetThreadTitle_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->title)::BaseType> title_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_title,
    title_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("SetThreadTitle");
#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 PageHandlerProxy::CloseSidePanel(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::CloseSidePanel");
#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::PageHandler::kCloseSidePanel), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_CloseSidePanel_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("CloseSidePanel");
#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 PageHandlerProxy::ShowThreadHistory(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::ShowThreadHistory");
#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::PageHandler::kShowThreadHistory), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_ShowThreadHistory_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("ShowThreadHistory");
#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 PageHandlerProxy::IsShownInTab(
    IsShownInTabCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::IsShownInTab");
#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::PageHandler::kIsShownInTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsShownInTab_Params_Data> params(
          message);
  params.Allocate();

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

void PageHandlerProxy::OpenMyActivityUi(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OpenMyActivityUi");
#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::PageHandler::kOpenMyActivityUi), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OpenMyActivityUi_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OpenMyActivityUi");
#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 PageHandlerProxy::OpenFeedbackUi(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OpenFeedbackUi");
#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::PageHandler::kOpenFeedbackUi), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OpenFeedbackUi_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OpenFeedbackUi");
#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 PageHandlerProxy::OpenOnboardingHelpUi(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OpenOnboardingHelpUi");
#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::PageHandler::kOpenOnboardingHelpUi), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OpenOnboardingHelpUi_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OpenOnboardingHelpUi");
#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 PageHandlerProxy::OpenOverflowMenuHelpUi(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OpenOverflowMenuHelpUi");
#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::PageHandler::kOpenOverflowMenuHelpUi), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OpenOverflowMenuHelpUi_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OpenOverflowMenuHelpUi");
#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 PageHandlerProxy::OpenUrl(
    const ::GURL& in_url, ::WindowOpenDisposition in_disposition) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::OpenUrl", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("disposition"), in_disposition,
                        "<value of type ::WindowOpenDisposition>");
   });
#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::PageHandler::kOpenUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OpenUrl_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

  
  mojo::internal::Serialize<::ui::mojom::WindowOpenDisposition>(
    in_disposition,
    &params->disposition);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OpenUrl");
#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 PageHandlerProxy::MoveTaskUiToNewTab(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::MoveTaskUiToNewTab");
#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::PageHandler::kMoveTaskUiToNewTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_MoveTaskUiToNewTab_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("MoveTaskUiToNewTab");
#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 PageHandlerProxy::OnTabClickedFromSourcesMenu(
    int32_t in_tab_id, const ::GURL& in_url) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::OnTabClickedFromSourcesMenu", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("tab_id"), in_tab_id,
                        "<value of type int32_t>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_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::PageHandler::kOnTabClickedFromSourcesMenu), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnTabClickedFromSourcesMenu_Params_Data> params(
          message);
  params.Allocate();

  params->tab_id = in_tab_id;
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnTabClickedFromSourcesMenu");
#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 PageHandlerProxy::OnFileClickedFromSourcesMenu(
    const ::GURL& in_url) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::OnFileClickedFromSourcesMenu", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_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::PageHandler::kOnFileClickedFromSourcesMenu), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnFileClickedFromSourcesMenu_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnFileClickedFromSourcesMenu");
#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 PageHandlerProxy::OnImageClickedFromSourcesMenu(
    const ::GURL& in_url) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::OnImageClickedFromSourcesMenu", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_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::PageHandler::kOnImageClickedFromSourcesMenu), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnImageClickedFromSourcesMenu_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnImageClickedFromSourcesMenu");
#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 PageHandlerProxy::OnWebviewMessage(
    const std::vector<uint8_t>& in_message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::OnWebviewMessage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("message"), in_message,
                        "<value of type const std::vector<uint8_t>&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kOnWebviewMessage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnWebviewMessage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->message)::BaseType>
      message_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& message_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
    in_message,
    message_fragment,
    &message_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnWebviewMessage");
#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 PageHandlerProxy::GetCommonSearchParams(
    bool in_is_dark_mode, bool in_is_side_panel, GetCommonSearchParamsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::GetCommonSearchParams", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_dark_mode"), in_is_dark_mode,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_side_panel"), in_is_side_panel,
                        "<value of type bool>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kGetCommonSearchParams), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_GetCommonSearchParams_Params_Data> params(
          message);
  params.Allocate();

  params->is_dark_mode = in_is_dark_mode;

  params->is_side_panel = in_is_side_panel;

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

void PageHandlerProxy::OnboardingTooltipDismissed(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OnboardingTooltipDismissed");
#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::PageHandler::kOnboardingTooltipDismissed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnboardingTooltipDismissed_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnboardingTooltipDismissed");
#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 PageHandlerProxy::LensSearchTooltipDismissed(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::LensSearchTooltipDismissed");
#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::PageHandler::kLensSearchTooltipDismissed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_LensSearchTooltipDismissed_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("LensSearchTooltipDismissed");
#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 PageHandlerProxy::AskGTooltipDismissed(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::AskGTooltipDismissed");
#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::PageHandler::kAskGTooltipDismissed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_AskGTooltipDismissed_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("AskGTooltipDismissed");
#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 PageHandlerProxy::ReopenTabs(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::ReopenTabs");
#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::PageHandler::kReopenTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_ReopenTabs_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("ReopenTabs");
#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 PageHandlerProxy::PinSidePanel(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::PinSidePanel");
#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::PageHandler::kPinSidePanel), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_PinSidePanel_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("PinSidePanel");
#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 PageHandlerProxy::UnpinSidePanel(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::UnpinSidePanel");
#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::PageHandler::kUnpinSidePanel), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_UnpinSidePanel_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("UnpinSidePanel");
#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 PageHandlerProxy::OnContextMenuOpened(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OnContextMenuOpened");
#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::PageHandler::kOnContextMenuOpened), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnContextMenuOpened_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnContextMenuOpened");
#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 PageHandlerProxy::NotifySmartTabSharingTryItIphResult(
    bool in_accepted) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::NotifySmartTabSharingTryItIphResult", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("accepted"), in_accepted,
                        "<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::PageHandler::kNotifySmartTabSharingTryItIphResult), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_NotifySmartTabSharingTryItIphResult_Params_Data> params(
          message);
  params.Allocate();

  params->accepted = in_accepted;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("NotifySmartTabSharingTryItIphResult");
#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 PageHandlerProxy::NotifySmartTabSharingDefaultOnIphResult(
    bool in_accepted) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::NotifySmartTabSharingDefaultOnIphResult", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("accepted"), in_accepted,
                        "<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::PageHandler::kNotifySmartTabSharingDefaultOnIphResult), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_NotifySmartTabSharingDefaultOnIphResult_Params_Data> params(
          message);
  params.Allocate();

  params->accepted = in_accepted;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("NotifySmartTabSharingDefaultOnIphResult");
#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 PageHandlerProxy::RegisterWindow(
    const ::contextual_tasks::ContextualTaskId& in_task_id, const ::GURL& in_url, const ::contextual_tasks::ContextualWindowId& in_window_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::RegisterWindow", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("task_id"), in_task_id,
                        "<value of type const ::contextual_tasks::ContextualTaskId&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("window_id"), in_window_id,
                        "<value of type const ::contextual_tasks::ContextualWindowId&>");
   });
#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::PageHandler::kRegisterWindow), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_RegisterWindow_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->task_id)::BaseType> task_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::contextual_tasks::mojom::ContextualTaskIdDataView>(
    in_task_id,
    task_id_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->task_id.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null task_id in PageHandler.RegisterWindow request");
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->url.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null url in PageHandler.RegisterWindow request");
  mojo::internal::MessageFragment<
      typename decltype(params->window_id)::BaseType> window_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::contextual_tasks::mojom::ContextualWindowIdDataView>(
    in_window_id,
    window_id_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("RegisterWindow");
#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 PageHandlerProxy::CloseWindow(
    const ::contextual_tasks::ContextualWindowId& in_window_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::CloseWindow", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("window_id"), in_window_id,
                        "<value of type const ::contextual_tasks::ContextualWindowId&>");
   });
#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::PageHandler::kCloseWindow), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_CloseWindow_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->window_id)::BaseType> window_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::contextual_tasks::mojom::ContextualWindowIdDataView>(
    in_window_id,
    window_id_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("CloseWindow");
#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 PageHandlerProxy::MaybeTriggerPinningPromo(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::MaybeTriggerPinningPromo");
#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::PageHandler::kMaybeTriggerPinningPromo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_MaybeTriggerPinningPromo_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("MaybeTriggerPinningPromo");
#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 PageHandlerProxy::ShowPageInfoBubble(
    bool in_is_pointer_interaction) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandler::ShowPageInfoBubble", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_pointer_interaction"), in_is_pointer_interaction,
                        "<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::PageHandler::kShowPageInfoBubble), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_ShowPageInfoBubble_Params_Data> params(
          message);
  params.Allocate();

  params->is_pointer_interaction = in_is_pointer_interaction;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("ShowPageInfoBubble");
#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 PageHandlerProxy::OnLogoPointerDown(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::OnLogoPointerDown");
#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::PageHandler::kOnLogoPointerDown), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_OnLogoPointerDown_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("OnLogoPointerDown");
#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 PageHandlerProxy::CreateNewThread(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::PageHandler::CreateNewThread");
#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::PageHandler::kCreateNewThread), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_CreateNewThread_Params_Data> params(
          message);
  params.Allocate();

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

  ~PageHandler_GetThreadUrl_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:
  PageHandler_GetThreadUrl_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)
        << "PageHandler::GetThreadUrlCallback 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 ::GURL& in_url);
};

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

  // Validation for PageHandler.0
  bool success = true;
  ::GURL p_url{};
  PageHandler_GetThreadUrl_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadUrl(&p_url))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        PageHandler::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_url));
  }
  return true;
}

void PageHandler_GetThreadUrl_ProxyToResponder::Run(
    const ::GURL& in_url) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::GetThreadUrl", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
   });
#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::PageHandler::kGetThreadUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_GetThreadUrl_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

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

  ~PageHandler_GetUrlForTask_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:
  PageHandler_GetUrlForTask_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)
        << "PageHandler::GetUrlForTaskCallback 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 ::GURL& in_url);
};

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

  // Validation for PageHandler.1
  bool success = true;
  ::GURL p_url{};
  PageHandler_GetUrlForTask_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadUrl(&p_url))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        PageHandler::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_url));
  }
  return true;
}

void PageHandler_GetUrlForTask_ProxyToResponder::Run(
    const ::GURL& in_url) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::GetUrlForTask", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
   });
#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::PageHandler::kGetUrlForTask), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_GetUrlForTask_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

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

  ~PageHandler_IsZeroState_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:
  PageHandler_IsZeroState_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)
        << "PageHandler::IsZeroStateCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_is_zero_state);
};

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

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

void PageHandler_IsZeroState_ProxyToResponder::Run(
    bool in_is_zero_state) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::IsZeroState", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_zero_state"), in_is_zero_state,
                        "<value of type bool>");
   });
#endif

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kIsZeroState), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsZeroState_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_zero_state = in_is_zero_state;

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

  ~PageHandler_IsAiPage_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:
  PageHandler_IsAiPage_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)
        << "PageHandler::IsAiPageCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_is_ai_page);
};

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

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

void PageHandler_IsAiPage_ProxyToResponder::Run(
    bool in_is_ai_page) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::IsAiPage", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_ai_page"), in_is_ai_page,
                        "<value of type bool>");
   });
#endif

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kIsAiPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsAiPage_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_ai_page = in_is_ai_page;

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

  ~PageHandler_IsPendingErrorPage_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:
  PageHandler_IsPendingErrorPage_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)
        << "PageHandler::IsPendingErrorPageCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_is_pending_error_page);
};

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

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

void PageHandler_IsPendingErrorPage_ProxyToResponder::Run(
    bool in_is_pending_error_page) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::IsPendingErrorPage", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_pending_error_page"), in_is_pending_error_page,
                        "<value of type bool>");
   });
#endif

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kIsPendingErrorPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsPendingErrorPage_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_pending_error_page = in_is_pending_error_page;

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

  ~PageHandler_IsEmbeddedPageErrorDocument_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:
  PageHandler_IsEmbeddedPageErrorDocument_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)
        << "PageHandler::IsEmbeddedPageErrorDocumentCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_is_error_document);
};

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

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

void PageHandler_IsEmbeddedPageErrorDocument_ProxyToResponder::Run(
    bool in_is_error_document) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::IsEmbeddedPageErrorDocument", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_error_document"), in_is_error_document,
                        "<value of type bool>");
   });
#endif

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kIsEmbeddedPageErrorDocument), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsEmbeddedPageErrorDocument_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_error_document = in_is_error_document;

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

  ~PageHandler_IsShownInTab_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:
  PageHandler_IsShownInTab_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)
        << "PageHandler::IsShownInTabCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_is_in_tab);
};

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

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

void PageHandler_IsShownInTab_ProxyToResponder::Run(
    bool in_is_in_tab) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::IsShownInTab", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_in_tab"), in_is_in_tab,
                        "<value of type bool>");
   });
#endif

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::PageHandler::kIsShownInTab), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_IsShownInTab_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->is_in_tab = in_is_in_tab;

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

  ~PageHandler_GetCommonSearchParams_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:
  PageHandler_GetCommonSearchParams_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)
        << "PageHandler::GetCommonSearchParamsCallback 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 base::flat_map<std::string, std::string>& in_params);
};

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

  // Validation for PageHandler.21
  bool success = true;
  base::flat_map<std::string, std::string> p_params{};
  PageHandler_GetCommonSearchParams_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadParams(&p_params))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        PageHandler::Name_, 21, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_params));
  }
  return true;
}

void PageHandler_GetCommonSearchParams_ProxyToResponder::Run(
    const base::flat_map<std::string, std::string>& in_params) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::PageHandler::GetCommonSearchParams", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type const base::flat_map<std::string, 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::PageHandler::kGetCommonSearchParams), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandler_GetCommonSearchParams_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType>
      params_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& params_validate_params =
      mojo::internal::GetMapValidator<*&mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>(), *&mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>()>();
  
  mojo::internal::Serialize<mojo::MapDataView<mojo::StringDataView, mojo::StringDataView>>(
    in_params,
    params_fragment,
    &params_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(PageHandler::Name_);
  message.set_method_name("GetCommonSearchParams");
#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 PageHandlerStubDispatch::Accept(
    PageHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::PageHandler>(message->header()->name)) {
    case messages::PageHandler::kGetThreadUrl: {
      break;
    }
    case messages::PageHandler::kGetUrlForTask: {
      break;
    }
    case messages::PageHandler::kSetTaskId: {
      DCHECK(message->is_serialized());
      internal::PageHandler_SetTaskId_Params_Data* params =
          reinterpret_cast<internal::PageHandler_SetTaskId_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.2
      bool success = true;
      ::base::Uuid p_uuid{};
      PageHandler_SetTaskId_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUuid(&p_uuid))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetTaskId(        
        std::move(p_uuid));
      return true;
    }
    case messages::PageHandler::kIsZeroState: {
      break;
    }
    case messages::PageHandler::kIsAiPage: {
      break;
    }
    case messages::PageHandler::kIsPendingErrorPage: {
      break;
    }
    case messages::PageHandler::kIsEmbeddedPageErrorDocument: {
      break;
    }
    case messages::PageHandler::kSetThreadTitle: {
      DCHECK(message->is_serialized());
      internal::PageHandler_SetThreadTitle_Params_Data* params =
          reinterpret_cast<internal::PageHandler_SetThreadTitle_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.7
      bool success = true;
      std::string p_title{};
      PageHandler_SetThreadTitle_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTitle(&p_title))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 7, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetThreadTitle(        
        std::move(p_title));
      return true;
    }
    case messages::PageHandler::kCloseSidePanel: {
      DCHECK(message->is_serialized());
      internal::PageHandler_CloseSidePanel_Params_Data* params =
          reinterpret_cast<internal::PageHandler_CloseSidePanel_Params_Data*>(
              message->mutable_payload());
      

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

      // Validation for PageHandler.9
      bool success = true;
      PageHandler_ShowThreadHistory_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 9, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowThreadHistory(        );
      return true;
    }
    case messages::PageHandler::kIsShownInTab: {
      break;
    }
    case messages::PageHandler::kOpenMyActivityUi: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OpenMyActivityUi_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OpenMyActivityUi_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.11
      bool success = true;
      PageHandler_OpenMyActivityUi_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 11, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenMyActivityUi(        );
      return true;
    }
    case messages::PageHandler::kOpenFeedbackUi: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OpenFeedbackUi_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OpenFeedbackUi_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.12
      bool success = true;
      PageHandler_OpenFeedbackUi_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 12, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenFeedbackUi(        );
      return true;
    }
    case messages::PageHandler::kOpenOnboardingHelpUi: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OpenOnboardingHelpUi_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OpenOnboardingHelpUi_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.13
      bool success = true;
      PageHandler_OpenOnboardingHelpUi_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 13, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenOnboardingHelpUi(        );
      return true;
    }
    case messages::PageHandler::kOpenOverflowMenuHelpUi: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OpenOverflowMenuHelpUi_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OpenOverflowMenuHelpUi_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.14
      bool success = true;
      PageHandler_OpenOverflowMenuHelpUi_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 14, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenOverflowMenuHelpUi(        );
      return true;
    }
    case messages::PageHandler::kOpenUrl: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OpenUrl_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OpenUrl_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.15
      bool success = true;
      ::GURL p_url{};
      ::WindowOpenDisposition p_disposition{};
      PageHandler_OpenUrl_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (success && !input_data_view.ReadDisposition(&p_disposition))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 15, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OpenUrl(        
        std::move(p_url), 
        std::move(p_disposition));
      return true;
    }
    case messages::PageHandler::kMoveTaskUiToNewTab: {
      DCHECK(message->is_serialized());
      internal::PageHandler_MoveTaskUiToNewTab_Params_Data* params =
          reinterpret_cast<internal::PageHandler_MoveTaskUiToNewTab_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.16
      bool success = true;
      PageHandler_MoveTaskUiToNewTab_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 16, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->MoveTaskUiToNewTab(        );
      return true;
    }
    case messages::PageHandler::kOnTabClickedFromSourcesMenu: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnTabClickedFromSourcesMenu_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnTabClickedFromSourcesMenu_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.17
      bool success = true;
      int32_t p_tab_id{};
      ::GURL p_url{};
      PageHandler_OnTabClickedFromSourcesMenu_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_tab_id = input_data_view.tab_id();
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 17, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnTabClickedFromSourcesMenu(        
        std::move(p_tab_id), 
        std::move(p_url));
      return true;
    }
    case messages::PageHandler::kOnFileClickedFromSourcesMenu: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnFileClickedFromSourcesMenu_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnFileClickedFromSourcesMenu_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.18
      bool success = true;
      ::GURL p_url{};
      PageHandler_OnFileClickedFromSourcesMenu_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 18, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnFileClickedFromSourcesMenu(        
        std::move(p_url));
      return true;
    }
    case messages::PageHandler::kOnImageClickedFromSourcesMenu: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnImageClickedFromSourcesMenu_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnImageClickedFromSourcesMenu_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.19
      bool success = true;
      ::GURL p_url{};
      PageHandler_OnImageClickedFromSourcesMenu_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 19, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnImageClickedFromSourcesMenu(        
        std::move(p_url));
      return true;
    }
    case messages::PageHandler::kOnWebviewMessage: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnWebviewMessage_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnWebviewMessage_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.20
      bool success = true;
      std::vector<uint8_t> p_message{};
      PageHandler_OnWebviewMessage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadMessage(&p_message))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 20, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnWebviewMessage(        
        std::move(p_message));
      return true;
    }
    case messages::PageHandler::kGetCommonSearchParams: {
      break;
    }
    case messages::PageHandler::kOnboardingTooltipDismissed: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnboardingTooltipDismissed_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnboardingTooltipDismissed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.22
      bool success = true;
      PageHandler_OnboardingTooltipDismissed_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 22, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnboardingTooltipDismissed(        );
      return true;
    }
    case messages::PageHandler::kLensSearchTooltipDismissed: {
      DCHECK(message->is_serialized());
      internal::PageHandler_LensSearchTooltipDismissed_Params_Data* params =
          reinterpret_cast<internal::PageHandler_LensSearchTooltipDismissed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.23
      bool success = true;
      PageHandler_LensSearchTooltipDismissed_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 23, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->LensSearchTooltipDismissed(        );
      return true;
    }
    case messages::PageHandler::kAskGTooltipDismissed: {
      DCHECK(message->is_serialized());
      internal::PageHandler_AskGTooltipDismissed_Params_Data* params =
          reinterpret_cast<internal::PageHandler_AskGTooltipDismissed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.24
      bool success = true;
      PageHandler_AskGTooltipDismissed_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 24, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AskGTooltipDismissed(        );
      return true;
    }
    case messages::PageHandler::kReopenTabs: {
      DCHECK(message->is_serialized());
      internal::PageHandler_ReopenTabs_Params_Data* params =
          reinterpret_cast<internal::PageHandler_ReopenTabs_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.25
      bool success = true;
      PageHandler_ReopenTabs_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 25, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ReopenTabs(        );
      return true;
    }
    case messages::PageHandler::kPinSidePanel: {
      DCHECK(message->is_serialized());
      internal::PageHandler_PinSidePanel_Params_Data* params =
          reinterpret_cast<internal::PageHandler_PinSidePanel_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.26
      bool success = true;
      PageHandler_PinSidePanel_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 26, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PinSidePanel(        );
      return true;
    }
    case messages::PageHandler::kUnpinSidePanel: {
      DCHECK(message->is_serialized());
      internal::PageHandler_UnpinSidePanel_Params_Data* params =
          reinterpret_cast<internal::PageHandler_UnpinSidePanel_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.27
      bool success = true;
      PageHandler_UnpinSidePanel_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 27, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UnpinSidePanel(        );
      return true;
    }
    case messages::PageHandler::kOnContextMenuOpened: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnContextMenuOpened_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnContextMenuOpened_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.28
      bool success = true;
      PageHandler_OnContextMenuOpened_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 28, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnContextMenuOpened(        );
      return true;
    }
    case messages::PageHandler::kNotifySmartTabSharingTryItIphResult: {
      DCHECK(message->is_serialized());
      internal::PageHandler_NotifySmartTabSharingTryItIphResult_Params_Data* params =
          reinterpret_cast<internal::PageHandler_NotifySmartTabSharingTryItIphResult_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.29
      bool success = true;
      bool p_accepted{};
      PageHandler_NotifySmartTabSharingTryItIphResult_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_accepted = input_data_view.accepted();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 29, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifySmartTabSharingTryItIphResult(        
        std::move(p_accepted));
      return true;
    }
    case messages::PageHandler::kNotifySmartTabSharingDefaultOnIphResult: {
      DCHECK(message->is_serialized());
      internal::PageHandler_NotifySmartTabSharingDefaultOnIphResult_Params_Data* params =
          reinterpret_cast<internal::PageHandler_NotifySmartTabSharingDefaultOnIphResult_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.30
      bool success = true;
      bool p_accepted{};
      PageHandler_NotifySmartTabSharingDefaultOnIphResult_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_accepted = input_data_view.accepted();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 30, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->NotifySmartTabSharingDefaultOnIphResult(        
        std::move(p_accepted));
      return true;
    }
    case messages::PageHandler::kRegisterWindow: {
      DCHECK(message->is_serialized());
      internal::PageHandler_RegisterWindow_Params_Data* params =
          reinterpret_cast<internal::PageHandler_RegisterWindow_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.31
      bool success = true;
      ::contextual_tasks::ContextualTaskId p_task_id{};
      ::GURL p_url{};
      ::contextual_tasks::ContextualWindowId p_window_id{};
      PageHandler_RegisterWindow_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTaskId(&p_task_id))
        success = false;
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (success && !input_data_view.ReadWindowId(&p_window_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 31, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RegisterWindow(        
        std::move(p_task_id), 
        std::move(p_url), 
        std::move(p_window_id));
      return true;
    }
    case messages::PageHandler::kCloseWindow: {
      DCHECK(message->is_serialized());
      internal::PageHandler_CloseWindow_Params_Data* params =
          reinterpret_cast<internal::PageHandler_CloseWindow_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.32
      bool success = true;
      ::contextual_tasks::ContextualWindowId p_window_id{};
      PageHandler_CloseWindow_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadWindowId(&p_window_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 32, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CloseWindow(        
        std::move(p_window_id));
      return true;
    }
    case messages::PageHandler::kMaybeTriggerPinningPromo: {
      DCHECK(message->is_serialized());
      internal::PageHandler_MaybeTriggerPinningPromo_Params_Data* params =
          reinterpret_cast<internal::PageHandler_MaybeTriggerPinningPromo_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.33
      bool success = true;
      PageHandler_MaybeTriggerPinningPromo_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 33, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->MaybeTriggerPinningPromo(        );
      return true;
    }
    case messages::PageHandler::kShowPageInfoBubble: {
      DCHECK(message->is_serialized());
      internal::PageHandler_ShowPageInfoBubble_Params_Data* params =
          reinterpret_cast<internal::PageHandler_ShowPageInfoBubble_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.34
      bool success = true;
      bool p_is_pointer_interaction{};
      PageHandler_ShowPageInfoBubble_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_pointer_interaction = input_data_view.is_pointer_interaction();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 34, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowPageInfoBubble(        
        std::move(p_is_pointer_interaction));
      return true;
    }
    case messages::PageHandler::kOnLogoPointerDown: {
      DCHECK(message->is_serialized());
      internal::PageHandler_OnLogoPointerDown_Params_Data* params =
          reinterpret_cast<internal::PageHandler_OnLogoPointerDown_Params_Data*>(
              message->mutable_payload());
      

      // Validation for PageHandler.35
      bool success = true;
      PageHandler_OnLogoPointerDown_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 35, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnLogoPointerDown(        );
      return true;
    }
    case messages::PageHandler::kCreateNewThread: {
      DCHECK(message->is_serialized());
      internal::PageHandler_CreateNewThread_Params_Data* params =
          reinterpret_cast<internal::PageHandler_CreateNewThread_Params_Data*>(
              message->mutable_payload());
      

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

// static
bool PageHandlerStubDispatch::AcceptWithResponder(
    PageHandler* 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::PageHandler>(message->header()->name)) {
    case messages::PageHandler::kGetThreadUrl: {
      internal::PageHandler_GetThreadUrl_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_GetThreadUrl_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.0
      bool success = true;
      PageHandler_GetThreadUrl_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          PageHandler_GetThreadUrl_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetThreadUrl(std::move(callback));
      return true;
    }
    case messages::PageHandler::kGetUrlForTask: {
      internal::PageHandler_GetUrlForTask_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_GetUrlForTask_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.1
      bool success = true;
      ::base::Uuid p_uuid{};
      PageHandler_GetUrlForTask_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUuid(&p_uuid))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 1, false);
        return false;
      }
      auto callback =
          PageHandler_GetUrlForTask_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetUrlForTask(        
        std::move(p_uuid), std::move(callback));
      return true;
    }
    case messages::PageHandler::kSetTaskId: {
      break;
    }
    case messages::PageHandler::kIsZeroState: {
      internal::PageHandler_IsZeroState_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_IsZeroState_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.3
      bool success = true;
      ::GURL p_url{};
      PageHandler_IsZeroState_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 3, false);
        return false;
      }
      auto callback =
          PageHandler_IsZeroState_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->IsZeroState(        
        std::move(p_url), std::move(callback));
      return true;
    }
    case messages::PageHandler::kIsAiPage: {
      internal::PageHandler_IsAiPage_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_IsAiPage_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.4
      bool success = true;
      ::GURL p_url{};
      PageHandler_IsAiPage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 4, false);
        return false;
      }
      auto callback =
          PageHandler_IsAiPage_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->IsAiPage(        
        std::move(p_url), std::move(callback));
      return true;
    }
    case messages::PageHandler::kIsPendingErrorPage: {
      internal::PageHandler_IsPendingErrorPage_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_IsPendingErrorPage_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.5
      bool success = true;
      ::base::Uuid p_task_id{};
      PageHandler_IsPendingErrorPage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTaskId(&p_task_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 5, false);
        return false;
      }
      auto callback =
          PageHandler_IsPendingErrorPage_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->IsPendingErrorPage(        
        std::move(p_task_id), std::move(callback));
      return true;
    }
    case messages::PageHandler::kIsEmbeddedPageErrorDocument: {
      internal::PageHandler_IsEmbeddedPageErrorDocument_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_IsEmbeddedPageErrorDocument_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.6
      bool success = true;
      PageHandler_IsEmbeddedPageErrorDocument_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 6, false);
        return false;
      }
      auto callback =
          PageHandler_IsEmbeddedPageErrorDocument_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->IsEmbeddedPageErrorDocument(std::move(callback));
      return true;
    }
    case messages::PageHandler::kSetThreadTitle: {
      break;
    }
    case messages::PageHandler::kCloseSidePanel: {
      break;
    }
    case messages::PageHandler::kShowThreadHistory: {
      break;
    }
    case messages::PageHandler::kIsShownInTab: {
      internal::PageHandler_IsShownInTab_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_IsShownInTab_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.10
      bool success = true;
      PageHandler_IsShownInTab_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 10, false);
        return false;
      }
      auto callback =
          PageHandler_IsShownInTab_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->IsShownInTab(std::move(callback));
      return true;
    }
    case messages::PageHandler::kOpenMyActivityUi: {
      break;
    }
    case messages::PageHandler::kOpenFeedbackUi: {
      break;
    }
    case messages::PageHandler::kOpenOnboardingHelpUi: {
      break;
    }
    case messages::PageHandler::kOpenOverflowMenuHelpUi: {
      break;
    }
    case messages::PageHandler::kOpenUrl: {
      break;
    }
    case messages::PageHandler::kMoveTaskUiToNewTab: {
      break;
    }
    case messages::PageHandler::kOnTabClickedFromSourcesMenu: {
      break;
    }
    case messages::PageHandler::kOnFileClickedFromSourcesMenu: {
      break;
    }
    case messages::PageHandler::kOnImageClickedFromSourcesMenu: {
      break;
    }
    case messages::PageHandler::kOnWebviewMessage: {
      break;
    }
    case messages::PageHandler::kGetCommonSearchParams: {
      internal::PageHandler_GetCommonSearchParams_Params_Data* params =
          reinterpret_cast<
              internal::PageHandler_GetCommonSearchParams_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for PageHandler.21
      bool success = true;
      bool p_is_dark_mode{};
      bool p_is_side_panel{};
      PageHandler_GetCommonSearchParams_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_dark_mode = input_data_view.is_dark_mode();
      if (success)
        p_is_side_panel = input_data_view.is_side_panel();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandler::Name_, 21, false);
        return false;
      }
      auto callback =
          PageHandler_GetCommonSearchParams_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetCommonSearchParams(        
        std::move(p_is_dark_mode), 
        std::move(p_is_side_panel), std::move(callback));
      return true;
    }
    case messages::PageHandler::kOnboardingTooltipDismissed: {
      break;
    }
    case messages::PageHandler::kLensSearchTooltipDismissed: {
      break;
    }
    case messages::PageHandler::kAskGTooltipDismissed: {
      break;
    }
    case messages::PageHandler::kReopenTabs: {
      break;
    }
    case messages::PageHandler::kPinSidePanel: {
      break;
    }
    case messages::PageHandler::kUnpinSidePanel: {
      break;
    }
    case messages::PageHandler::kOnContextMenuOpened: {
      break;
    }
    case messages::PageHandler::kNotifySmartTabSharingTryItIphResult: {
      break;
    }
    case messages::PageHandler::kNotifySmartTabSharingDefaultOnIphResult: {
      break;
    }
    case messages::PageHandler::kRegisterWindow: {
      break;
    }
    case messages::PageHandler::kCloseWindow: {
      break;
    }
    case messages::PageHandler::kMaybeTriggerPinningPromo: {
      break;
    }
    case messages::PageHandler::kShowPageInfoBubble: {
      break;
    }
    case messages::PageHandler::kOnLogoPointerDown: {
      break;
    }
    case messages::PageHandler::kCreateNewThread: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kPageHandlerValidationInfo[] = {
    { &internal::PageHandler_GetThreadUrl_Params_Data::Validate,
     &internal::PageHandler_GetThreadUrl_ResponseParams_Data::Validate},
    { &internal::PageHandler_GetUrlForTask_Params_Data::Validate,
     &internal::PageHandler_GetUrlForTask_ResponseParams_Data::Validate},
    { &internal::PageHandler_SetTaskId_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_IsZeroState_Params_Data::Validate,
     &internal::PageHandler_IsZeroState_ResponseParams_Data::Validate},
    { &internal::PageHandler_IsAiPage_Params_Data::Validate,
     &internal::PageHandler_IsAiPage_ResponseParams_Data::Validate},
    { &internal::PageHandler_IsPendingErrorPage_Params_Data::Validate,
     &internal::PageHandler_IsPendingErrorPage_ResponseParams_Data::Validate},
    { &internal::PageHandler_IsEmbeddedPageErrorDocument_Params_Data::Validate,
     &internal::PageHandler_IsEmbeddedPageErrorDocument_ResponseParams_Data::Validate},
    { &internal::PageHandler_SetThreadTitle_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_CloseSidePanel_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_ShowThreadHistory_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_IsShownInTab_Params_Data::Validate,
     &internal::PageHandler_IsShownInTab_ResponseParams_Data::Validate},
    { &internal::PageHandler_OpenMyActivityUi_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OpenFeedbackUi_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OpenOnboardingHelpUi_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OpenOverflowMenuHelpUi_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OpenUrl_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_MoveTaskUiToNewTab_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OnTabClickedFromSourcesMenu_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OnFileClickedFromSourcesMenu_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OnImageClickedFromSourcesMenu_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OnWebviewMessage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_GetCommonSearchParams_Params_Data::Validate,
     &internal::PageHandler_GetCommonSearchParams_ResponseParams_Data::Validate},
    { &internal::PageHandler_OnboardingTooltipDismissed_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_LensSearchTooltipDismissed_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_AskGTooltipDismissed_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_ReopenTabs_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_PinSidePanel_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_UnpinSidePanel_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OnContextMenuOpened_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_NotifySmartTabSharingTryItIphResult_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_NotifySmartTabSharingDefaultOnIphResult_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_RegisterWindow_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_CloseWindow_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_MaybeTriggerPinningPromo_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_ShowPageInfoBubble_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_OnLogoPointerDown_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::PageHandler_CreateNewThread_Params_Data::Validate,
     nullptr /* no response */},
};

bool PageHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::contextual_tasks::mojom::PageHandler::Name_,
    kPageHandlerValidationInfo);
}

bool PageHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::contextual_tasks::mojom::PageHandler::Name_,
    kPageHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

Page::IPCStableHashFunction Page::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::Page>(message.name())) {
    case messages::Page::kSetThreadTitle: {
      return &Page::SetThreadTitle_Sym::IPCStableHash;
    }
    case messages::Page::kSetTaskDetails: {
      return &Page::SetTaskDetails_Sym::IPCStableHash;
    }
    case messages::Page::kOnSidePanelStateChanged: {
      return &Page::OnSidePanelStateChanged_Sym::IPCStableHash;
    }
    case messages::Page::kPostAimMessage: {
      return &Page::PostAimMessage_Sym::IPCStableHash;
    }
    case messages::Page::kOnHandshakeComplete: {
      return &Page::OnHandshakeComplete_Sym::IPCStableHash;
    }
    case messages::Page::kSetOAuthToken: {
      return &Page::SetOAuthToken_Sym::IPCStableHash;
    }
    case messages::Page::kOnCookieSyncCompleted: {
      return &Page::OnCookieSyncCompleted_Sym::IPCStableHash;
    }
    case messages::Page::kOnContextUpdated: {
      return &Page::OnContextUpdated_Sym::IPCStableHash;
    }
    case messages::Page::kHideInput: {
      return &Page::HideInput_Sym::IPCStableHash;
    }
    case messages::Page::kRestoreInput: {
      return &Page::RestoreInput_Sym::IPCStableHash;
    }
    case messages::Page::kEnterBasicMode: {
      return &Page::EnterBasicMode_Sym::IPCStableHash;
    }
    case messages::Page::kExitBasicMode: {
      return &Page::ExitBasicMode_Sym::IPCStableHash;
    }
    case messages::Page::kInjectInput: {
      return &Page::InjectInput_Sym::IPCStableHash;
    }
    case messages::Page::kRemoveInjectedInput: {
      return &Page::RemoveInjectedInput_Sym::IPCStableHash;
    }
    case messages::Page::kOnZeroStateChange: {
      return &Page::OnZeroStateChange_Sym::IPCStableHash;
    }
    case messages::Page::kSetInNlm: {
      return &Page::SetInNlm_Sym::IPCStableHash;
    }
    case messages::Page::kOnAiPageStatusChanged: {
      return &Page::OnAiPageStatusChanged_Sym::IPCStableHash;
    }
    case messages::Page::kOnLensOverlayStateChanged: {
      return &Page::OnLensOverlayStateChanged_Sym::IPCStableHash;
    }
    case messages::Page::kShowErrorPage: {
      return &Page::ShowErrorPage_Sym::IPCStableHash;
    }
    case messages::Page::kHideErrorPage: {
      return &Page::HideErrorPage_Sym::IPCStableHash;
    }
    case messages::Page::kShowOauthErrorDialog: {
      return &Page::ShowOauthErrorDialog_Sym::IPCStableHash;
    }
    case messages::Page::kUpdateComposeboxPosition: {
      return &Page::UpdateComposeboxPosition_Sym::IPCStableHash;
    }
    case messages::Page::kLockInput: {
      return &Page::LockInput_Sym::IPCStableHash;
    }
    case messages::Page::kUnlockInput: {
      return &Page::UnlockInput_Sym::IPCStableHash;
    }
    case messages::Page::kSetShowReopenTabs: {
      return &Page::SetShowReopenTabs_Sym::IPCStableHash;
    }
    case messages::Page::kOnSidePanelPinStateChanged: {
      return &Page::OnSidePanelPinStateChanged_Sym::IPCStableHash;
    }
    case messages::Page::kSetExpandButtonEnabled: {
      return &Page::SetExpandButtonEnabled_Sym::IPCStableHash;
    }
    case messages::Page::kTurnOnSmartTabSharing: {
      return &Page::TurnOnSmartTabSharing_Sym::IPCStableHash;
    }
    case messages::Page::kShowSmartTabSharingTryItIph: {
      return &Page::ShowSmartTabSharingTryItIph_Sym::IPCStableHash;
    }
    case messages::Page::kShowSmartTabSharingDefaultOnIph: {
      return &Page::ShowSmartTabSharingDefaultOnIph_Sym::IPCStableHash;
    }
    case messages::Page::kOnWindowClosed: {
      return &Page::OnWindowClosed_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* Page::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::Page>(message.name())) {
      case messages::Page::kSetThreadTitle:
            return "Receive contextual_tasks::mojom::Page::SetThreadTitle";
      case messages::Page::kSetTaskDetails:
            return "Receive contextual_tasks::mojom::Page::SetTaskDetails";
      case messages::Page::kOnSidePanelStateChanged:
            return "Receive contextual_tasks::mojom::Page::OnSidePanelStateChanged";
      case messages::Page::kPostAimMessage:
            return "Receive contextual_tasks::mojom::Page::PostAimMessage";
      case messages::Page::kOnHandshakeComplete:
            return "Receive contextual_tasks::mojom::Page::OnHandshakeComplete";
      case messages::Page::kSetOAuthToken:
            return "Receive contextual_tasks::mojom::Page::SetOAuthToken";
      case messages::Page::kOnCookieSyncCompleted:
            return "Receive contextual_tasks::mojom::Page::OnCookieSyncCompleted";
      case messages::Page::kOnContextUpdated:
            return "Receive contextual_tasks::mojom::Page::OnContextUpdated";
      case messages::Page::kHideInput:
            return "Receive contextual_tasks::mojom::Page::HideInput";
      case messages::Page::kRestoreInput:
            return "Receive contextual_tasks::mojom::Page::RestoreInput";
      case messages::Page::kEnterBasicMode:
            return "Receive contextual_tasks::mojom::Page::EnterBasicMode";
      case messages::Page::kExitBasicMode:
            return "Receive contextual_tasks::mojom::Page::ExitBasicMode";
      case messages::Page::kInjectInput:
            return "Receive contextual_tasks::mojom::Page::InjectInput";
      case messages::Page::kRemoveInjectedInput:
            return "Receive contextual_tasks::mojom::Page::RemoveInjectedInput";
      case messages::Page::kOnZeroStateChange:
            return "Receive contextual_tasks::mojom::Page::OnZeroStateChange";
      case messages::Page::kSetInNlm:
            return "Receive contextual_tasks::mojom::Page::SetInNlm";
      case messages::Page::kOnAiPageStatusChanged:
            return "Receive contextual_tasks::mojom::Page::OnAiPageStatusChanged";
      case messages::Page::kOnLensOverlayStateChanged:
            return "Receive contextual_tasks::mojom::Page::OnLensOverlayStateChanged";
      case messages::Page::kShowErrorPage:
            return "Receive contextual_tasks::mojom::Page::ShowErrorPage";
      case messages::Page::kHideErrorPage:
            return "Receive contextual_tasks::mojom::Page::HideErrorPage";
      case messages::Page::kShowOauthErrorDialog:
            return "Receive contextual_tasks::mojom::Page::ShowOauthErrorDialog";
      case messages::Page::kUpdateComposeboxPosition:
            return "Receive contextual_tasks::mojom::Page::UpdateComposeboxPosition";
      case messages::Page::kLockInput:
            return "Receive contextual_tasks::mojom::Page::LockInput";
      case messages::Page::kUnlockInput:
            return "Receive contextual_tasks::mojom::Page::UnlockInput";
      case messages::Page::kSetShowReopenTabs:
            return "Receive contextual_tasks::mojom::Page::SetShowReopenTabs";
      case messages::Page::kOnSidePanelPinStateChanged:
            return "Receive contextual_tasks::mojom::Page::OnSidePanelPinStateChanged";
      case messages::Page::kSetExpandButtonEnabled:
            return "Receive contextual_tasks::mojom::Page::SetExpandButtonEnabled";
      case messages::Page::kTurnOnSmartTabSharing:
            return "Receive contextual_tasks::mojom::Page::TurnOnSmartTabSharing";
      case messages::Page::kShowSmartTabSharingTryItIph:
            return "Receive contextual_tasks::mojom::Page::ShowSmartTabSharingTryItIph";
      case messages::Page::kShowSmartTabSharingDefaultOnIph:
            return "Receive contextual_tasks::mojom::Page::ShowSmartTabSharingDefaultOnIph";
      case messages::Page::kOnWindowClosed:
            return "Receive contextual_tasks::mojom::Page::OnWindowClosed";
    }
  } else {
    switch (static_cast<messages::Page>(message.name())) {
      case messages::Page::kSetThreadTitle:
            return "Receive reply contextual_tasks::mojom::Page::SetThreadTitle";
      case messages::Page::kSetTaskDetails:
            return "Receive reply contextual_tasks::mojom::Page::SetTaskDetails";
      case messages::Page::kOnSidePanelStateChanged:
            return "Receive reply contextual_tasks::mojom::Page::OnSidePanelStateChanged";
      case messages::Page::kPostAimMessage:
            return "Receive reply contextual_tasks::mojom::Page::PostAimMessage";
      case messages::Page::kOnHandshakeComplete:
            return "Receive reply contextual_tasks::mojom::Page::OnHandshakeComplete";
      case messages::Page::kSetOAuthToken:
            return "Receive reply contextual_tasks::mojom::Page::SetOAuthToken";
      case messages::Page::kOnCookieSyncCompleted:
            return "Receive reply contextual_tasks::mojom::Page::OnCookieSyncCompleted";
      case messages::Page::kOnContextUpdated:
            return "Receive reply contextual_tasks::mojom::Page::OnContextUpdated";
      case messages::Page::kHideInput:
            return "Receive reply contextual_tasks::mojom::Page::HideInput";
      case messages::Page::kRestoreInput:
            return "Receive reply contextual_tasks::mojom::Page::RestoreInput";
      case messages::Page::kEnterBasicMode:
            return "Receive reply contextual_tasks::mojom::Page::EnterBasicMode";
      case messages::Page::kExitBasicMode:
            return "Receive reply contextual_tasks::mojom::Page::ExitBasicMode";
      case messages::Page::kInjectInput:
            return "Receive reply contextual_tasks::mojom::Page::InjectInput";
      case messages::Page::kRemoveInjectedInput:
            return "Receive reply contextual_tasks::mojom::Page::RemoveInjectedInput";
      case messages::Page::kOnZeroStateChange:
            return "Receive reply contextual_tasks::mojom::Page::OnZeroStateChange";
      case messages::Page::kSetInNlm:
            return "Receive reply contextual_tasks::mojom::Page::SetInNlm";
      case messages::Page::kOnAiPageStatusChanged:
            return "Receive reply contextual_tasks::mojom::Page::OnAiPageStatusChanged";
      case messages::Page::kOnLensOverlayStateChanged:
            return "Receive reply contextual_tasks::mojom::Page::OnLensOverlayStateChanged";
      case messages::Page::kShowErrorPage:
            return "Receive reply contextual_tasks::mojom::Page::ShowErrorPage";
      case messages::Page::kHideErrorPage:
            return "Receive reply contextual_tasks::mojom::Page::HideErrorPage";
      case messages::Page::kShowOauthErrorDialog:
            return "Receive reply contextual_tasks::mojom::Page::ShowOauthErrorDialog";
      case messages::Page::kUpdateComposeboxPosition:
            return "Receive reply contextual_tasks::mojom::Page::UpdateComposeboxPosition";
      case messages::Page::kLockInput:
            return "Receive reply contextual_tasks::mojom::Page::LockInput";
      case messages::Page::kUnlockInput:
            return "Receive reply contextual_tasks::mojom::Page::UnlockInput";
      case messages::Page::kSetShowReopenTabs:
            return "Receive reply contextual_tasks::mojom::Page::SetShowReopenTabs";
      case messages::Page::kOnSidePanelPinStateChanged:
            return "Receive reply contextual_tasks::mojom::Page::OnSidePanelPinStateChanged";
      case messages::Page::kSetExpandButtonEnabled:
            return "Receive reply contextual_tasks::mojom::Page::SetExpandButtonEnabled";
      case messages::Page::kTurnOnSmartTabSharing:
            return "Receive reply contextual_tasks::mojom::Page::TurnOnSmartTabSharing";
      case messages::Page::kShowSmartTabSharingTryItIph:
            return "Receive reply contextual_tasks::mojom::Page::ShowSmartTabSharingTryItIph";
      case messages::Page::kShowSmartTabSharingDefaultOnIph:
            return "Receive reply contextual_tasks::mojom::Page::ShowSmartTabSharingDefaultOnIph";
      case messages::Page::kOnWindowClosed:
            return "Receive reply contextual_tasks::mojom::Page::OnWindowClosed";
    }
  }
  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 Page::SetThreadTitle_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 = 0x11c5721c;  // IPCStableHash for contextual_tasks::mojom::Page::SetThreadTitle
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::SetTaskDetails_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 = 0x0e4aafbf;  // IPCStableHash for contextual_tasks::mojom::Page::SetTaskDetails
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnSidePanelStateChanged_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 = 0xee9b6f87;  // IPCStableHash for contextual_tasks::mojom::Page::OnSidePanelStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::PostAimMessage_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 = 0x38e1d4c4;  // IPCStableHash for contextual_tasks::mojom::Page::PostAimMessage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnHandshakeComplete_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 = 0xc124e9a8;  // IPCStableHash for contextual_tasks::mojom::Page::OnHandshakeComplete
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::SetOAuthToken_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 = 0xac7c644b;  // IPCStableHash for contextual_tasks::mojom::Page::SetOAuthToken
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnCookieSyncCompleted_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 = 0x2989dafb;  // IPCStableHash for contextual_tasks::mojom::Page::OnCookieSyncCompleted
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnContextUpdated_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 = 0xe5eff780;  // IPCStableHash for contextual_tasks::mojom::Page::OnContextUpdated
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::HideInput_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 = 0x9235964c;  // IPCStableHash for contextual_tasks::mojom::Page::HideInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::RestoreInput_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 = 0x37cab50a;  // IPCStableHash for contextual_tasks::mojom::Page::RestoreInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::EnterBasicMode_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 = 0xa1b08940;  // IPCStableHash for contextual_tasks::mojom::Page::EnterBasicMode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::ExitBasicMode_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 = 0x953c358a;  // IPCStableHash for contextual_tasks::mojom::Page::ExitBasicMode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::InjectInput_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 = 0x4f06c638;  // IPCStableHash for contextual_tasks::mojom::Page::InjectInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::RemoveInjectedInput_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 = 0x4069f0e4;  // IPCStableHash for contextual_tasks::mojom::Page::RemoveInjectedInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnZeroStateChange_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 = 0x116b8f83;  // IPCStableHash for contextual_tasks::mojom::Page::OnZeroStateChange
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::SetInNlm_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 = 0xbcbcade2;  // IPCStableHash for contextual_tasks::mojom::Page::SetInNlm
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnAiPageStatusChanged_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 = 0xf07f1ee5;  // IPCStableHash for contextual_tasks::mojom::Page::OnAiPageStatusChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnLensOverlayStateChanged_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 = 0x3681823c;  // IPCStableHash for contextual_tasks::mojom::Page::OnLensOverlayStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::ShowErrorPage_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 = 0x88dca8f8;  // IPCStableHash for contextual_tasks::mojom::Page::ShowErrorPage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::HideErrorPage_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 = 0x76db7956;  // IPCStableHash for contextual_tasks::mojom::Page::HideErrorPage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::ShowOauthErrorDialog_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 = 0xe6cfefc9;  // IPCStableHash for contextual_tasks::mojom::Page::ShowOauthErrorDialog
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::UpdateComposeboxPosition_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 = 0xa02383a1;  // IPCStableHash for contextual_tasks::mojom::Page::UpdateComposeboxPosition
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::LockInput_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 = 0x1374a7ae;  // IPCStableHash for contextual_tasks::mojom::Page::LockInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::UnlockInput_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 = 0x97a13ae6;  // IPCStableHash for contextual_tasks::mojom::Page::UnlockInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::SetShowReopenTabs_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 = 0xea116f39;  // IPCStableHash for contextual_tasks::mojom::Page::SetShowReopenTabs
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnSidePanelPinStateChanged_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 = 0xf31637a6;  // IPCStableHash for contextual_tasks::mojom::Page::OnSidePanelPinStateChanged
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::SetExpandButtonEnabled_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 = 0x18672a07;  // IPCStableHash for contextual_tasks::mojom::Page::SetExpandButtonEnabled
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::TurnOnSmartTabSharing_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 = 0xcb8c5343;  // IPCStableHash for contextual_tasks::mojom::Page::TurnOnSmartTabSharing
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::ShowSmartTabSharingTryItIph_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 = 0xb7b3f531;  // IPCStableHash for contextual_tasks::mojom::Page::ShowSmartTabSharingTryItIph
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::ShowSmartTabSharingDefaultOnIph_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 = 0xf7da1aa3;  // IPCStableHash for contextual_tasks::mojom::Page::ShowSmartTabSharingDefaultOnIph
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t Page::OnWindowClosed_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 = 0xa04ccfa1;  // IPCStableHash for contextual_tasks::mojom::Page::OnWindowClosed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void PageProxy::SetThreadTitle(
    const std::string& in_title) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::SetThreadTitle", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("title"), in_title,
                        "<value of type const std::string&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::Page::kSetThreadTitle), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_SetThreadTitle_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->title)::BaseType> title_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_title,
    title_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("SetThreadTitle");
#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 PageProxy::SetTaskDetails(
    const ::base::Uuid& in_uuid, const ::GURL& in_url, bool in_replace_navigation_entry) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::SetTaskDetails", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("uuid"), in_uuid,
                        "<value of type const ::base::Uuid&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("replace_navigation_entry"), in_replace_navigation_entry,
                        "<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::Page::kSetTaskDetails), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_SetTaskDetails_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->uuid)::BaseType> uuid_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_uuid,
    uuid_fragment);

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

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->uuid.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null uuid in Page.SetTaskDetails request");
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

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

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

  params->replace_navigation_entry = in_replace_navigation_entry;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("SetTaskDetails");
#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 PageProxy::OnSidePanelStateChanged(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::OnSidePanelStateChanged");
#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::Page::kOnSidePanelStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnSidePanelStateChanged_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnSidePanelStateChanged");
#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 PageProxy::PostAimMessage(
    const std::vector<uint8_t>& in_message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::PostAimMessage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("message"), in_message,
                        "<value of type const std::vector<uint8_t>&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::Page::kPostAimMessage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_PostAimMessage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->message)::BaseType>
      message_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& message_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
    in_message,
    message_fragment,
    &message_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("PostAimMessage");
#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 PageProxy::OnHandshakeComplete(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::OnHandshakeComplete");
#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::Page::kOnHandshakeComplete), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnHandshakeComplete_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnHandshakeComplete");
#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 PageProxy::SetOAuthToken(
    const std::string& in_oauth_token) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::SetOAuthToken", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("oauth_token"), in_oauth_token,
                        "<value of type const std::string&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::Page::kSetOAuthToken), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_SetOAuthToken_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->oauth_token)::BaseType> oauth_token_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_oauth_token,
    oauth_token_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("SetOAuthToken");
#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 PageProxy::OnCookieSyncCompleted(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::OnCookieSyncCompleted");
#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::Page::kOnCookieSyncCompleted), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnCookieSyncCompleted_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnCookieSyncCompleted");
#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 PageProxy::OnContextUpdated(
    std::vector<ContextInfoPtr> in_context) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::OnContextUpdated", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("context"), in_context,
                        "<value of type std::vector<ContextInfoPtr>>");
   });
#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::Page::kOnContextUpdated), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnContextUpdated_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->context)::BaseType>
      context_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& context_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::contextual_tasks::mojom::ContextInfoDataView>>(
    in_context,
    context_fragment,
    &context_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnContextUpdated");
#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 PageProxy::HideInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::HideInput");
#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::Page::kHideInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_HideInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("HideInput");
#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 PageProxy::RestoreInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::RestoreInput");
#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::Page::kRestoreInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_RestoreInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("RestoreInput");
#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 PageProxy::EnterBasicMode(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::EnterBasicMode");
#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::Page::kEnterBasicMode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_EnterBasicMode_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("EnterBasicMode");
#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 PageProxy::ExitBasicMode(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::ExitBasicMode");
#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::Page::kExitBasicMode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_ExitBasicMode_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("ExitBasicMode");
#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 PageProxy::InjectInput(
    InjectedInputPtr in_input) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::InjectInput", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("input"), in_input,
                        "<value of type InjectedInputPtr>");
   });
#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::Page::kInjectInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_InjectInput_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->input)::BaseType> input_fragment(
          params.message());
  
  mojo::internal::Serialize<::contextual_tasks::mojom::InjectedInputDataView>(
    in_input,
    input_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("InjectInput");
#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 PageProxy::RemoveInjectedInput(
    const ::base::UnguessableToken& in_file_token) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::RemoveInjectedInput", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("file_token"), in_file_token,
                        "<value of type const ::base::UnguessableToken&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::Page::kRemoveInjectedInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_RemoveInjectedInput_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->file_token)::BaseType> file_token_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView>(
    in_file_token,
    file_token_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("RemoveInjectedInput");
#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 PageProxy::OnZeroStateChange(
    bool in_is_zero_state) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::OnZeroStateChange", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_zero_state"), in_is_zero_state,
                        "<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::Page::kOnZeroStateChange), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnZeroStateChange_Params_Data> params(
          message);
  params.Allocate();

  params->is_zero_state = in_is_zero_state;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnZeroStateChange");
#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 PageProxy::SetInNlm(
    bool in_in_nlm) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::SetInNlm", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("in_nlm"), in_in_nlm,
                        "<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::Page::kSetInNlm), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_SetInNlm_Params_Data> params(
          message);
  params.Allocate();

  params->in_nlm = in_in_nlm;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("SetInNlm");
#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 PageProxy::OnAiPageStatusChanged(
    bool in_is_ai_page) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::OnAiPageStatusChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_ai_page"), in_is_ai_page,
                        "<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::Page::kOnAiPageStatusChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnAiPageStatusChanged_Params_Data> params(
          message);
  params.Allocate();

  params->is_ai_page = in_is_ai_page;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnAiPageStatusChanged");
#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 PageProxy::OnLensOverlayStateChanged(
    bool in_is_showing, bool in_maybe_show_overlay_hint_text) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::OnLensOverlayStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_showing"), in_is_showing,
                        "<value of type bool>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("maybe_show_overlay_hint_text"), in_maybe_show_overlay_hint_text,
                        "<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::Page::kOnLensOverlayStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnLensOverlayStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->is_showing = in_is_showing;

  params->maybe_show_overlay_hint_text = in_maybe_show_overlay_hint_text;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnLensOverlayStateChanged");
#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 PageProxy::ShowErrorPage(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::ShowErrorPage");
#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::Page::kShowErrorPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_ShowErrorPage_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("ShowErrorPage");
#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 PageProxy::HideErrorPage(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::HideErrorPage");
#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::Page::kHideErrorPage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_HideErrorPage_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("HideErrorPage");
#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 PageProxy::ShowOauthErrorDialog(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::ShowOauthErrorDialog");
#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::Page::kShowOauthErrorDialog), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_ShowOauthErrorDialog_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("ShowOauthErrorDialog");
#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 PageProxy::UpdateComposeboxPosition(
    ComposeboxPositionPtr in_position) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::UpdateComposeboxPosition", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("position"), in_position,
                        "<value of type ComposeboxPositionPtr>");
   });
#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::Page::kUpdateComposeboxPosition), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_UpdateComposeboxPosition_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->position)::BaseType> position_fragment(
          params.message());
  
  mojo::internal::Serialize<::contextual_tasks::mojom::ComposeboxPositionDataView>(
    in_position,
    position_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("UpdateComposeboxPosition");
#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 PageProxy::LockInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::LockInput");
#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::Page::kLockInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_LockInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("LockInput");
#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 PageProxy::UnlockInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::UnlockInput");
#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::Page::kUnlockInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_UnlockInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("UnlockInput");
#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 PageProxy::SetShowReopenTabs(
    bool in_show) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::SetShowReopenTabs", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("show"), in_show,
                        "<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::Page::kSetShowReopenTabs), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_SetShowReopenTabs_Params_Data> params(
          message);
  params.Allocate();

  params->show = in_show;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("SetShowReopenTabs");
#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 PageProxy::OnSidePanelPinStateChanged(
    bool in_is_pinned) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::OnSidePanelPinStateChanged", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("is_pinned"), in_is_pinned,
                        "<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::Page::kOnSidePanelPinStateChanged), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnSidePanelPinStateChanged_Params_Data> params(
          message);
  params.Allocate();

  params->is_pinned = in_is_pinned;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("OnSidePanelPinStateChanged");
#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 PageProxy::SetExpandButtonEnabled(
    bool in_enabled) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::SetExpandButtonEnabled", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("enabled"), in_enabled,
                        "<value of type bool>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::Page::kSetExpandButtonEnabled), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_SetExpandButtonEnabled_Params_Data> params(
          message);
  params.Allocate();

  params->enabled = in_enabled;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("SetExpandButtonEnabled");
#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 PageProxy::TurnOnSmartTabSharing(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::TurnOnSmartTabSharing");
#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::Page::kTurnOnSmartTabSharing), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_TurnOnSmartTabSharing_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("TurnOnSmartTabSharing");
#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 PageProxy::ShowSmartTabSharingTryItIph(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::ShowSmartTabSharingTryItIph");
#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::Page::kShowSmartTabSharingTryItIph), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_ShowSmartTabSharingTryItIph_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("ShowSmartTabSharingTryItIph");
#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 PageProxy::ShowSmartTabSharingDefaultOnIph(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::Page::ShowSmartTabSharingDefaultOnIph");
#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::Page::kShowSmartTabSharingDefaultOnIph), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_ShowSmartTabSharingDefaultOnIph_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(Page::Name_);
  message.set_method_name("ShowSmartTabSharingDefaultOnIph");
#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 PageProxy::OnWindowClosed(
    const ::contextual_tasks::ContextualWindowId& in_window_id) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::Page::OnWindowClosed", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("window_id"), in_window_id,
                        "<value of type const ::contextual_tasks::ContextualWindowId&>");
   });
#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::Page::kOnWindowClosed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::Page_OnWindowClosed_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->window_id)::BaseType> window_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::contextual_tasks::mojom::ContextualWindowIdDataView>(
    in_window_id,
    window_id_fragment);

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

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

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

      // Validation for Page.0
      bool success = true;
      std::string p_title{};
      Page_SetThreadTitle_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadTitle(&p_title))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetThreadTitle(        
        std::move(p_title));
      return true;
    }
    case messages::Page::kSetTaskDetails: {
      DCHECK(message->is_serialized());
      internal::Page_SetTaskDetails_Params_Data* params =
          reinterpret_cast<internal::Page_SetTaskDetails_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.1
      bool success = true;
      ::base::Uuid p_uuid{};
      ::GURL p_url{};
      bool p_replace_navigation_entry{};
      Page_SetTaskDetails_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUuid(&p_uuid))
        success = false;
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (success)
        p_replace_navigation_entry = input_data_view.replace_navigation_entry();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetTaskDetails(        
        std::move(p_uuid), 
        std::move(p_url), 
        std::move(p_replace_navigation_entry));
      return true;
    }
    case messages::Page::kOnSidePanelStateChanged: {
      DCHECK(message->is_serialized());
      internal::Page_OnSidePanelStateChanged_Params_Data* params =
          reinterpret_cast<internal::Page_OnSidePanelStateChanged_Params_Data*>(
              message->mutable_payload());
      

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

      // Validation for Page.3
      bool success = true;
      std::vector<uint8_t> p_message{};
      Page_PostAimMessage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadMessage(&p_message))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PostAimMessage(        
        std::move(p_message));
      return true;
    }
    case messages::Page::kOnHandshakeComplete: {
      DCHECK(message->is_serialized());
      internal::Page_OnHandshakeComplete_Params_Data* params =
          reinterpret_cast<internal::Page_OnHandshakeComplete_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.4
      bool success = true;
      Page_OnHandshakeComplete_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnHandshakeComplete(        );
      return true;
    }
    case messages::Page::kSetOAuthToken: {
      DCHECK(message->is_serialized());
      internal::Page_SetOAuthToken_Params_Data* params =
          reinterpret_cast<internal::Page_SetOAuthToken_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.5
      bool success = true;
      std::string p_oauth_token{};
      Page_SetOAuthToken_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOauthToken(&p_oauth_token))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 5, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetOAuthToken(        
        std::move(p_oauth_token));
      return true;
    }
    case messages::Page::kOnCookieSyncCompleted: {
      DCHECK(message->is_serialized());
      internal::Page_OnCookieSyncCompleted_Params_Data* params =
          reinterpret_cast<internal::Page_OnCookieSyncCompleted_Params_Data*>(
              message->mutable_payload());
      

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

      // Validation for Page.7
      bool success = true;
      std::vector<ContextInfoPtr> p_context{};
      Page_OnContextUpdated_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadContext(&p_context))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 7, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnContextUpdated(        
        std::move(p_context));
      return true;
    }
    case messages::Page::kHideInput: {
      DCHECK(message->is_serialized());
      internal::Page_HideInput_Params_Data* params =
          reinterpret_cast<internal::Page_HideInput_Params_Data*>(
              message->mutable_payload());
      

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

      // Validation for Page.9
      bool success = true;
      Page_RestoreInput_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 9, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RestoreInput(        );
      return true;
    }
    case messages::Page::kEnterBasicMode: {
      DCHECK(message->is_serialized());
      internal::Page_EnterBasicMode_Params_Data* params =
          reinterpret_cast<internal::Page_EnterBasicMode_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.10
      bool success = true;
      Page_EnterBasicMode_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 10, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->EnterBasicMode(        );
      return true;
    }
    case messages::Page::kExitBasicMode: {
      DCHECK(message->is_serialized());
      internal::Page_ExitBasicMode_Params_Data* params =
          reinterpret_cast<internal::Page_ExitBasicMode_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.11
      bool success = true;
      Page_ExitBasicMode_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 11, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ExitBasicMode(        );
      return true;
    }
    case messages::Page::kInjectInput: {
      DCHECK(message->is_serialized());
      internal::Page_InjectInput_Params_Data* params =
          reinterpret_cast<internal::Page_InjectInput_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.12
      bool success = true;
      InjectedInputPtr p_input{};
      Page_InjectInput_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadInput(&p_input))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 12, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->InjectInput(        
        std::move(p_input));
      return true;
    }
    case messages::Page::kRemoveInjectedInput: {
      DCHECK(message->is_serialized());
      internal::Page_RemoveInjectedInput_Params_Data* params =
          reinterpret_cast<internal::Page_RemoveInjectedInput_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.13
      bool success = true;
      ::base::UnguessableToken p_file_token{};
      Page_RemoveInjectedInput_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadFileToken(&p_file_token))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 13, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RemoveInjectedInput(        
        std::move(p_file_token));
      return true;
    }
    case messages::Page::kOnZeroStateChange: {
      DCHECK(message->is_serialized());
      internal::Page_OnZeroStateChange_Params_Data* params =
          reinterpret_cast<internal::Page_OnZeroStateChange_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.14
      bool success = true;
      bool p_is_zero_state{};
      Page_OnZeroStateChange_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_zero_state = input_data_view.is_zero_state();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 14, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnZeroStateChange(        
        std::move(p_is_zero_state));
      return true;
    }
    case messages::Page::kSetInNlm: {
      DCHECK(message->is_serialized());
      internal::Page_SetInNlm_Params_Data* params =
          reinterpret_cast<internal::Page_SetInNlm_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.15
      bool success = true;
      bool p_in_nlm{};
      Page_SetInNlm_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_in_nlm = input_data_view.in_nlm();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 15, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetInNlm(        
        std::move(p_in_nlm));
      return true;
    }
    case messages::Page::kOnAiPageStatusChanged: {
      DCHECK(message->is_serialized());
      internal::Page_OnAiPageStatusChanged_Params_Data* params =
          reinterpret_cast<internal::Page_OnAiPageStatusChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.16
      bool success = true;
      bool p_is_ai_page{};
      Page_OnAiPageStatusChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_ai_page = input_data_view.is_ai_page();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 16, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnAiPageStatusChanged(        
        std::move(p_is_ai_page));
      return true;
    }
    case messages::Page::kOnLensOverlayStateChanged: {
      DCHECK(message->is_serialized());
      internal::Page_OnLensOverlayStateChanged_Params_Data* params =
          reinterpret_cast<internal::Page_OnLensOverlayStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.17
      bool success = true;
      bool p_is_showing{};
      bool p_maybe_show_overlay_hint_text{};
      Page_OnLensOverlayStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_showing = input_data_view.is_showing();
      if (success)
        p_maybe_show_overlay_hint_text = input_data_view.maybe_show_overlay_hint_text();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 17, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnLensOverlayStateChanged(        
        std::move(p_is_showing), 
        std::move(p_maybe_show_overlay_hint_text));
      return true;
    }
    case messages::Page::kShowErrorPage: {
      DCHECK(message->is_serialized());
      internal::Page_ShowErrorPage_Params_Data* params =
          reinterpret_cast<internal::Page_ShowErrorPage_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.18
      bool success = true;
      Page_ShowErrorPage_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 18, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowErrorPage(        );
      return true;
    }
    case messages::Page::kHideErrorPage: {
      DCHECK(message->is_serialized());
      internal::Page_HideErrorPage_Params_Data* params =
          reinterpret_cast<internal::Page_HideErrorPage_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.19
      bool success = true;
      Page_HideErrorPage_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 19, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->HideErrorPage(        );
      return true;
    }
    case messages::Page::kShowOauthErrorDialog: {
      DCHECK(message->is_serialized());
      internal::Page_ShowOauthErrorDialog_Params_Data* params =
          reinterpret_cast<internal::Page_ShowOauthErrorDialog_Params_Data*>(
              message->mutable_payload());
      

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

      // Validation for Page.21
      bool success = true;
      ComposeboxPositionPtr p_position{};
      Page_UpdateComposeboxPosition_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadPosition(&p_position))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 21, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UpdateComposeboxPosition(        
        std::move(p_position));
      return true;
    }
    case messages::Page::kLockInput: {
      DCHECK(message->is_serialized());
      internal::Page_LockInput_Params_Data* params =
          reinterpret_cast<internal::Page_LockInput_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.22
      bool success = true;
      Page_LockInput_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 22, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->LockInput(        );
      return true;
    }
    case messages::Page::kUnlockInput: {
      DCHECK(message->is_serialized());
      internal::Page_UnlockInput_Params_Data* params =
          reinterpret_cast<internal::Page_UnlockInput_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.23
      bool success = true;
      Page_UnlockInput_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 23, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UnlockInput(        );
      return true;
    }
    case messages::Page::kSetShowReopenTabs: {
      DCHECK(message->is_serialized());
      internal::Page_SetShowReopenTabs_Params_Data* params =
          reinterpret_cast<internal::Page_SetShowReopenTabs_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.24
      bool success = true;
      bool p_show{};
      Page_SetShowReopenTabs_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_show = input_data_view.show();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 24, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetShowReopenTabs(        
        std::move(p_show));
      return true;
    }
    case messages::Page::kOnSidePanelPinStateChanged: {
      DCHECK(message->is_serialized());
      internal::Page_OnSidePanelPinStateChanged_Params_Data* params =
          reinterpret_cast<internal::Page_OnSidePanelPinStateChanged_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.25
      bool success = true;
      bool p_is_pinned{};
      Page_OnSidePanelPinStateChanged_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_is_pinned = input_data_view.is_pinned();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 25, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnSidePanelPinStateChanged(        
        std::move(p_is_pinned));
      return true;
    }
    case messages::Page::kSetExpandButtonEnabled: {
      DCHECK(message->is_serialized());
      internal::Page_SetExpandButtonEnabled_Params_Data* params =
          reinterpret_cast<internal::Page_SetExpandButtonEnabled_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.26
      bool success = true;
      bool p_enabled{};
      Page_SetExpandButtonEnabled_ParamsDataView input_data_view(params, message);
      
      if (success)
        p_enabled = input_data_view.enabled();
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 26, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetExpandButtonEnabled(        
        std::move(p_enabled));
      return true;
    }
    case messages::Page::kTurnOnSmartTabSharing: {
      DCHECK(message->is_serialized());
      internal::Page_TurnOnSmartTabSharing_Params_Data* params =
          reinterpret_cast<internal::Page_TurnOnSmartTabSharing_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.27
      bool success = true;
      Page_TurnOnSmartTabSharing_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 27, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->TurnOnSmartTabSharing(        );
      return true;
    }
    case messages::Page::kShowSmartTabSharingTryItIph: {
      DCHECK(message->is_serialized());
      internal::Page_ShowSmartTabSharingTryItIph_Params_Data* params =
          reinterpret_cast<internal::Page_ShowSmartTabSharingTryItIph_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.28
      bool success = true;
      Page_ShowSmartTabSharingTryItIph_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 28, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowSmartTabSharingTryItIph(        );
      return true;
    }
    case messages::Page::kShowSmartTabSharingDefaultOnIph: {
      DCHECK(message->is_serialized());
      internal::Page_ShowSmartTabSharingDefaultOnIph_Params_Data* params =
          reinterpret_cast<internal::Page_ShowSmartTabSharingDefaultOnIph_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.29
      bool success = true;
      Page_ShowSmartTabSharingDefaultOnIph_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 29, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ShowSmartTabSharingDefaultOnIph(        );
      return true;
    }
    case messages::Page::kOnWindowClosed: {
      DCHECK(message->is_serialized());
      internal::Page_OnWindowClosed_Params_Data* params =
          reinterpret_cast<internal::Page_OnWindowClosed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for Page.30
      bool success = true;
      ::contextual_tasks::ContextualWindowId p_window_id{};
      Page_OnWindowClosed_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadWindowId(&p_window_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            Page::Name_, 30, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnWindowClosed(        
        std::move(p_window_id));
      return true;
    }
  }
  return false;
}

// static
bool PageStubDispatch::AcceptWithResponder(
    Page* 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::Page>(message->header()->name)) {
    case messages::Page::kSetThreadTitle: {
      break;
    }
    case messages::Page::kSetTaskDetails: {
      break;
    }
    case messages::Page::kOnSidePanelStateChanged: {
      break;
    }
    case messages::Page::kPostAimMessage: {
      break;
    }
    case messages::Page::kOnHandshakeComplete: {
      break;
    }
    case messages::Page::kSetOAuthToken: {
      break;
    }
    case messages::Page::kOnCookieSyncCompleted: {
      break;
    }
    case messages::Page::kOnContextUpdated: {
      break;
    }
    case messages::Page::kHideInput: {
      break;
    }
    case messages::Page::kRestoreInput: {
      break;
    }
    case messages::Page::kEnterBasicMode: {
      break;
    }
    case messages::Page::kExitBasicMode: {
      break;
    }
    case messages::Page::kInjectInput: {
      break;
    }
    case messages::Page::kRemoveInjectedInput: {
      break;
    }
    case messages::Page::kOnZeroStateChange: {
      break;
    }
    case messages::Page::kSetInNlm: {
      break;
    }
    case messages::Page::kOnAiPageStatusChanged: {
      break;
    }
    case messages::Page::kOnLensOverlayStateChanged: {
      break;
    }
    case messages::Page::kShowErrorPage: {
      break;
    }
    case messages::Page::kHideErrorPage: {
      break;
    }
    case messages::Page::kShowOauthErrorDialog: {
      break;
    }
    case messages::Page::kUpdateComposeboxPosition: {
      break;
    }
    case messages::Page::kLockInput: {
      break;
    }
    case messages::Page::kUnlockInput: {
      break;
    }
    case messages::Page::kSetShowReopenTabs: {
      break;
    }
    case messages::Page::kOnSidePanelPinStateChanged: {
      break;
    }
    case messages::Page::kSetExpandButtonEnabled: {
      break;
    }
    case messages::Page::kTurnOnSmartTabSharing: {
      break;
    }
    case messages::Page::kShowSmartTabSharingTryItIph: {
      break;
    }
    case messages::Page::kShowSmartTabSharingDefaultOnIph: {
      break;
    }
    case messages::Page::kOnWindowClosed: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kPageValidationInfo[] = {
    { &internal::Page_SetThreadTitle_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_SetTaskDetails_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnSidePanelStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_PostAimMessage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnHandshakeComplete_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_SetOAuthToken_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnCookieSyncCompleted_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnContextUpdated_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_HideInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_RestoreInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_EnterBasicMode_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_ExitBasicMode_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_InjectInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_RemoveInjectedInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnZeroStateChange_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_SetInNlm_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnAiPageStatusChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnLensOverlayStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_ShowErrorPage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_HideErrorPage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_ShowOauthErrorDialog_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_UpdateComposeboxPosition_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_LockInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_UnlockInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_SetShowReopenTabs_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnSidePanelPinStateChanged_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_SetExpandButtonEnabled_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_TurnOnSmartTabSharing_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_ShowSmartTabSharingTryItIph_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_ShowSmartTabSharingDefaultOnIph_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::Page_OnWindowClosed_Params_Data::Validate,
     nullptr /* no response */},
};

bool PageRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::contextual_tasks::mojom::Page::Name_,
    kPageValidationInfo);
}

// The declaration includes the definition on other builds.

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


const char* PageHandlerFactory::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::PageHandlerFactory>(message.name())) {
      case messages::PageHandlerFactory::kCreatePageHandler:
            return "Receive contextual_tasks::mojom::PageHandlerFactory::CreatePageHandler";
    }
  } else {
    switch (static_cast<messages::PageHandlerFactory>(message.name())) {
      case messages::PageHandlerFactory::kCreatePageHandler:
            return "Receive reply contextual_tasks::mojom::PageHandlerFactory::CreatePageHandler";
    }
  }
  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 PageHandlerFactory::CreatePageHandler_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 = 0x0695ffc9;  // IPCStableHash for contextual_tasks::mojom::PageHandlerFactory::CreatePageHandler
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void PageHandlerFactoryProxy::CreatePageHandler(
    ::mojo::PendingRemote<Page> in_page, ::mojo::PendingReceiver<PageHandler> in_page_handler) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::PageHandlerFactory::CreatePageHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("page"), in_page,
                        "<value of type ::mojo::PendingRemote<Page>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("page_handler"), in_page_handler,
                        "<value of type ::mojo::PendingReceiver<PageHandler>>");
   });
#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::PageHandlerFactory::kCreatePageHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::PageHandlerFactory_CreatePageHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::contextual_tasks::mojom::PageInterfaceBase>>(
    in_page,
    &params->page,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->page)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid page in PageHandlerFactory.CreatePageHandler request");

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::contextual_tasks::mojom::PageHandlerInterfaceBase>>(
    in_page_handler,
    &params->page_handler,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->page_handler)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid page_handler in PageHandlerFactory.CreatePageHandler request");

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

      // Validation for PageHandlerFactory.0
      bool success = true;
      ::mojo::PendingRemote<Page> p_page{};
      ::mojo::PendingReceiver<PageHandler> p_page_handler{};
      PageHandlerFactory_CreatePageHandler_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_page =
            input_data_view.TakePage<decltype(p_page)>();
      }
      if (success) {
        p_page_handler =
            input_data_view.TakePageHandler<decltype(p_page_handler)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            PageHandlerFactory::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreatePageHandler(        
        std::move(p_page), 
        std::move(p_page_handler));
      return true;
    }
  }
  return false;
}

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

bool PageHandlerFactoryRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::contextual_tasks::mojom::PageHandlerFactory::Name_,
    kPageHandlerFactoryValidationInfo);
}

// The declaration includes the definition on other builds.

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


const char* ExtensionPageHandlerFactory::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::ExtensionPageHandlerFactory>(message.name())) {
      case messages::ExtensionPageHandlerFactory::kCreateExtensionPageHandler:
            return "Receive contextual_tasks::mojom::ExtensionPageHandlerFactory::CreateExtensionPageHandler";
    }
  } else {
    switch (static_cast<messages::ExtensionPageHandlerFactory>(message.name())) {
      case messages::ExtensionPageHandlerFactory::kCreateExtensionPageHandler:
            return "Receive reply contextual_tasks::mojom::ExtensionPageHandlerFactory::CreateExtensionPageHandler";
    }
  }
  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 ExtensionPageHandlerFactory::CreateExtensionPageHandler_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 = 0xd510b987;  // IPCStableHash for contextual_tasks::mojom::ExtensionPageHandlerFactory::CreateExtensionPageHandler
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void ExtensionPageHandlerFactoryProxy::CreateExtensionPageHandler(
    ::mojo::PendingRemote<ExtensionPage> in_page, ::mojo::PendingReceiver<ExtensionPageHandler> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::ExtensionPageHandlerFactory::CreateExtensionPageHandler", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("page"), in_page,
                        "<value of type ::mojo::PendingRemote<ExtensionPage>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("receiver"), in_receiver,
                        "<value of type ::mojo::PendingReceiver<ExtensionPageHandler>>");
   });
#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::ExtensionPageHandlerFactory::kCreateExtensionPageHandler), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPageHandlerFactory_CreateExtensionPageHandler_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::contextual_tasks::mojom::ExtensionPageInterfaceBase>>(
    in_page,
    &params->page,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->page)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid page in ExtensionPageHandlerFactory.CreateExtensionPageHandler request");

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::contextual_tasks::mojom::ExtensionPageHandlerInterfaceBase>>(
    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 ExtensionPageHandlerFactory.CreateExtensionPageHandler request");

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

      // Validation for ExtensionPageHandlerFactory.0
      bool success = true;
      ::mojo::PendingRemote<ExtensionPage> p_page{};
      ::mojo::PendingReceiver<ExtensionPageHandler> p_receiver{};
      ExtensionPageHandlerFactory_CreateExtensionPageHandler_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_page =
            input_data_view.TakePage<decltype(p_page)>();
      }
      if (success) {
        p_receiver =
            input_data_view.TakeReceiver<decltype(p_receiver)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPageHandlerFactory::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateExtensionPageHandler(        
        std::move(p_page), 
        std::move(p_receiver));
      return true;
    }
  }
  return false;
}

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

bool ExtensionPageHandlerFactoryRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::contextual_tasks::mojom::ExtensionPageHandlerFactory::Name_,
    kExtensionPageHandlerFactoryValidationInfo);
}

// The declaration includes the definition on other builds.

ExtensionPageHandler::IPCStableHashFunction ExtensionPageHandler::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ExtensionPageHandler>(message.name())) {
    case messages::ExtensionPageHandler::kGetHandshakeMessage: {
      return &ExtensionPageHandler::GetHandshakeMessage_Sym::IPCStableHash;
    }
    case messages::ExtensionPageHandler::kOnWebviewMessage: {
      return &ExtensionPageHandler::OnWebviewMessage_Sym::IPCStableHash;
    }
    case messages::ExtensionPageHandler::kSetTaskId: {
      return &ExtensionPageHandler::SetTaskId_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ExtensionPageHandler::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::ExtensionPageHandler>(message.name())) {
      case messages::ExtensionPageHandler::kGetHandshakeMessage:
            return "Receive contextual_tasks::mojom::ExtensionPageHandler::GetHandshakeMessage";
      case messages::ExtensionPageHandler::kOnWebviewMessage:
            return "Receive contextual_tasks::mojom::ExtensionPageHandler::OnWebviewMessage";
      case messages::ExtensionPageHandler::kSetTaskId:
            return "Receive contextual_tasks::mojom::ExtensionPageHandler::SetTaskId";
    }
  } else {
    switch (static_cast<messages::ExtensionPageHandler>(message.name())) {
      case messages::ExtensionPageHandler::kGetHandshakeMessage:
            return "Receive reply contextual_tasks::mojom::ExtensionPageHandler::GetHandshakeMessage";
      case messages::ExtensionPageHandler::kOnWebviewMessage:
            return "Receive reply contextual_tasks::mojom::ExtensionPageHandler::OnWebviewMessage";
      case messages::ExtensionPageHandler::kSetTaskId:
            return "Receive reply contextual_tasks::mojom::ExtensionPageHandler::SetTaskId";
    }
  }
  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 ExtensionPageHandler::GetHandshakeMessage_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 = 0x8ef636d8;  // IPCStableHash for contextual_tasks::mojom::ExtensionPageHandler::GetHandshakeMessage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPageHandler::OnWebviewMessage_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 = 0x90d51e44;  // IPCStableHash for contextual_tasks::mojom::ExtensionPageHandler::OnWebviewMessage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPageHandler::SetTaskId_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 = 0x51f39e38;  // IPCStableHash for contextual_tasks::mojom::ExtensionPageHandler::SetTaskId
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class ExtensionPageHandler_GetHandshakeMessage_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  ExtensionPageHandler_GetHandshakeMessage_ForwardToCallback(
      ExtensionPageHandler::GetHandshakeMessageCallback callback
      ) : callback_(std::move(callback)) {
  }

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

  bool Accept(mojo::Message* message) override;
 private:
  ExtensionPageHandler::GetHandshakeMessageCallback callback_;
};

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

void ExtensionPageHandlerProxy::GetHandshakeMessage(
    GetHandshakeMessageCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPageHandler::GetHandshakeMessage");
#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::ExtensionPageHandler::kGetHandshakeMessage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPageHandler_GetHandshakeMessage_Params_Data> params(
          message);
  params.Allocate();

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

void ExtensionPageHandlerProxy::OnWebviewMessage(
    const std::vector<uint8_t>& in_message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::ExtensionPageHandler::OnWebviewMessage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("message"), in_message,
                        "<value of type const std::vector<uint8_t>&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ExtensionPageHandler::kOnWebviewMessage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPageHandler_OnWebviewMessage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->message)::BaseType>
      message_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& message_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
    in_message,
    message_fragment,
    &message_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPageHandler::Name_);
  message.set_method_name("OnWebviewMessage");
#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 ExtensionPageHandlerProxy::SetTaskId(
    const ::base::Uuid& in_uuid) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::ExtensionPageHandler::SetTaskId", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("uuid"), in_uuid,
                        "<value of type const ::base::Uuid&>");
   });
#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::ExtensionPageHandler::kSetTaskId), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPageHandler_SetTaskId_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->uuid)::BaseType> uuid_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_uuid,
    uuid_fragment);

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

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

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

  ~ExtensionPageHandler_GetHandshakeMessage_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:
  ExtensionPageHandler_GetHandshakeMessage_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)
        << "ExtensionPageHandler::GetHandshakeMessageCallback 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(
      ::mojo_base::ProtoWrapper in_message);
};

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

  // Validation for ExtensionPageHandler.0
  bool success = true;
  ::mojo_base::ProtoWrapper p_message{mojo::internal::DefaultConstructTag()};
  ExtensionPageHandler_GetHandshakeMessage_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadMessage(&p_message))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        ExtensionPageHandler::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_message));
  }
  return true;
}

void ExtensionPageHandler_GetHandshakeMessage_ProxyToResponder::Run(
    ::mojo_base::ProtoWrapper in_message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply contextual_tasks::mojom::ExtensionPageHandler::GetHandshakeMessage", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("message"), in_message,
                        "<value of type ::mojo_base::ProtoWrapper>");
   });
#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::ExtensionPageHandler::kGetHandshakeMessage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPageHandler_GetHandshakeMessage_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->message)::BaseType> message_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::ProtoWrapperDataView>(
    in_message,
    message_fragment);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPageHandler::Name_);
  message.set_method_name("GetHandshakeMessage");
#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 ExtensionPageHandlerStubDispatch::Accept(
    ExtensionPageHandler* impl,
    mojo::Message* message) {
  switch (static_cast<messages::ExtensionPageHandler>(message->header()->name)) {
    case messages::ExtensionPageHandler::kGetHandshakeMessage: {
      break;
    }
    case messages::ExtensionPageHandler::kOnWebviewMessage: {
      DCHECK(message->is_serialized());
      internal::ExtensionPageHandler_OnWebviewMessage_Params_Data* params =
          reinterpret_cast<internal::ExtensionPageHandler_OnWebviewMessage_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ExtensionPageHandler.1
      bool success = true;
      std::vector<uint8_t> p_message{};
      ExtensionPageHandler_OnWebviewMessage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadMessage(&p_message))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPageHandler::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnWebviewMessage(        
        std::move(p_message));
      return true;
    }
    case messages::ExtensionPageHandler::kSetTaskId: {
      DCHECK(message->is_serialized());
      internal::ExtensionPageHandler_SetTaskId_Params_Data* params =
          reinterpret_cast<internal::ExtensionPageHandler_SetTaskId_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ExtensionPageHandler.2
      bool success = true;
      ::base::Uuid p_uuid{};
      ExtensionPageHandler_SetTaskId_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUuid(&p_uuid))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPageHandler::Name_, 2, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetTaskId(        
        std::move(p_uuid));
      return true;
    }
  }
  return false;
}

// static
bool ExtensionPageHandlerStubDispatch::AcceptWithResponder(
    ExtensionPageHandler* 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::ExtensionPageHandler>(message->header()->name)) {
    case messages::ExtensionPageHandler::kGetHandshakeMessage: {
      internal::ExtensionPageHandler_GetHandshakeMessage_Params_Data* params =
          reinterpret_cast<
              internal::ExtensionPageHandler_GetHandshakeMessage_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for ExtensionPageHandler.0
      bool success = true;
      ExtensionPageHandler_GetHandshakeMessage_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPageHandler::Name_, 0, false);
        return false;
      }
      auto callback =
          ExtensionPageHandler_GetHandshakeMessage_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetHandshakeMessage(std::move(callback));
      return true;
    }
    case messages::ExtensionPageHandler::kOnWebviewMessage: {
      break;
    }
    case messages::ExtensionPageHandler::kSetTaskId: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kExtensionPageHandlerValidationInfo[] = {
    { &internal::ExtensionPageHandler_GetHandshakeMessage_Params_Data::Validate,
     &internal::ExtensionPageHandler_GetHandshakeMessage_ResponseParams_Data::Validate},
    { &internal::ExtensionPageHandler_OnWebviewMessage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPageHandler_SetTaskId_Params_Data::Validate,
     nullptr /* no response */},
};

bool ExtensionPageHandlerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::contextual_tasks::mojom::ExtensionPageHandler::Name_,
    kExtensionPageHandlerValidationInfo);
}

bool ExtensionPageHandlerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::contextual_tasks::mojom::ExtensionPageHandler::Name_,
    kExtensionPageHandlerValidationInfo);
}
// The declaration includes the definition on other builds.

ExtensionPage::IPCStableHashFunction ExtensionPage::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::ExtensionPage>(message.name())) {
    case messages::ExtensionPage::kPostAimMessage: {
      return &ExtensionPage::PostAimMessage_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kOnHandshakeComplete: {
      return &ExtensionPage::OnHandshakeComplete_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kHideInput: {
      return &ExtensionPage::HideInput_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kRestoreInput: {
      return &ExtensionPage::RestoreInput_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kEnterBasicMode: {
      return &ExtensionPage::EnterBasicMode_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kExitBasicMode: {
      return &ExtensionPage::ExitBasicMode_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kLockInput: {
      return &ExtensionPage::LockInput_Sym::IPCStableHash;
    }
    case messages::ExtensionPage::kUnlockInput: {
      return &ExtensionPage::UnlockInput_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* ExtensionPage::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::ExtensionPage>(message.name())) {
      case messages::ExtensionPage::kPostAimMessage:
            return "Receive contextual_tasks::mojom::ExtensionPage::PostAimMessage";
      case messages::ExtensionPage::kOnHandshakeComplete:
            return "Receive contextual_tasks::mojom::ExtensionPage::OnHandshakeComplete";
      case messages::ExtensionPage::kHideInput:
            return "Receive contextual_tasks::mojom::ExtensionPage::HideInput";
      case messages::ExtensionPage::kRestoreInput:
            return "Receive contextual_tasks::mojom::ExtensionPage::RestoreInput";
      case messages::ExtensionPage::kEnterBasicMode:
            return "Receive contextual_tasks::mojom::ExtensionPage::EnterBasicMode";
      case messages::ExtensionPage::kExitBasicMode:
            return "Receive contextual_tasks::mojom::ExtensionPage::ExitBasicMode";
      case messages::ExtensionPage::kLockInput:
            return "Receive contextual_tasks::mojom::ExtensionPage::LockInput";
      case messages::ExtensionPage::kUnlockInput:
            return "Receive contextual_tasks::mojom::ExtensionPage::UnlockInput";
    }
  } else {
    switch (static_cast<messages::ExtensionPage>(message.name())) {
      case messages::ExtensionPage::kPostAimMessage:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::PostAimMessage";
      case messages::ExtensionPage::kOnHandshakeComplete:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::OnHandshakeComplete";
      case messages::ExtensionPage::kHideInput:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::HideInput";
      case messages::ExtensionPage::kRestoreInput:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::RestoreInput";
      case messages::ExtensionPage::kEnterBasicMode:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::EnterBasicMode";
      case messages::ExtensionPage::kExitBasicMode:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::ExitBasicMode";
      case messages::ExtensionPage::kLockInput:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::LockInput";
      case messages::ExtensionPage::kUnlockInput:
            return "Receive reply contextual_tasks::mojom::ExtensionPage::UnlockInput";
    }
  }
  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 ExtensionPage::PostAimMessage_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 = 0x29232957;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::PostAimMessage
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::OnHandshakeComplete_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 = 0xa82995b0;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::OnHandshakeComplete
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::HideInput_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 = 0x0d68bc4c;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::HideInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::RestoreInput_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 = 0x322feb3b;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::RestoreInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::EnterBasicMode_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 = 0x8e71b609;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::EnterBasicMode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::ExitBasicMode_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 = 0xc5ae3d23;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::ExitBasicMode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::LockInput_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 = 0x9e45c3fa;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::LockInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t ExtensionPage::UnlockInput_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 = 0x92900906;  // IPCStableHash for contextual_tasks::mojom::ExtensionPage::UnlockInput
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void ExtensionPageProxy::PostAimMessage(
    const std::vector<uint8_t>& in_message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send contextual_tasks::mojom::ExtensionPage::PostAimMessage", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("message"), in_message,
                        "<value of type const std::vector<uint8_t>&>");
   });
#endif

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

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

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::ExtensionPage::kPostAimMessage), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_PostAimMessage_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->message)::BaseType>
      message_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& message_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
    in_message,
    message_fragment,
    &message_validate_params);

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

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

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("PostAimMessage");
#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 ExtensionPageProxy::OnHandshakeComplete(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::OnHandshakeComplete");
#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::ExtensionPage::kOnHandshakeComplete), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_OnHandshakeComplete_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("OnHandshakeComplete");
#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 ExtensionPageProxy::HideInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::HideInput");
#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::ExtensionPage::kHideInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_HideInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("HideInput");
#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 ExtensionPageProxy::RestoreInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::RestoreInput");
#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::ExtensionPage::kRestoreInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_RestoreInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("RestoreInput");
#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 ExtensionPageProxy::EnterBasicMode(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::EnterBasicMode");
#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::ExtensionPage::kEnterBasicMode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_EnterBasicMode_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("EnterBasicMode");
#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 ExtensionPageProxy::ExitBasicMode(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::ExitBasicMode");
#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::ExtensionPage::kExitBasicMode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_ExitBasicMode_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("ExitBasicMode");
#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 ExtensionPageProxy::LockInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::LockInput");
#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::ExtensionPage::kLockInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_LockInput_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(ExtensionPage::Name_);
  message.set_method_name("LockInput");
#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 ExtensionPageProxy::UnlockInput(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send contextual_tasks::mojom::ExtensionPage::UnlockInput");
#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::ExtensionPage::kUnlockInput), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::contextual_tasks::mojom::internal::ExtensionPage_UnlockInput_Params_Data> params(
          message);
  params.Allocate();

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

      // Validation for ExtensionPage.0
      bool success = true;
      std::vector<uint8_t> p_message{};
      ExtensionPage_PostAimMessage_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadMessage(&p_message))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPage::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PostAimMessage(        
        std::move(p_message));
      return true;
    }
    case messages::ExtensionPage::kOnHandshakeComplete: {
      DCHECK(message->is_serialized());
      internal::ExtensionPage_OnHandshakeComplete_Params_Data* params =
          reinterpret_cast<internal::ExtensionPage_OnHandshakeComplete_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ExtensionPage.1
      bool success = true;
      ExtensionPage_OnHandshakeComplete_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPage::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnHandshakeComplete(        );
      return true;
    }
    case messages::ExtensionPage::kHideInput: {
      DCHECK(message->is_serialized());
      internal::ExtensionPage_HideInput_Params_Data* params =
          reinterpret_cast<internal::ExtensionPage_HideInput_Params_Data*>(
              message->mutable_payload());
      

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

      // Validation for ExtensionPage.3
      bool success = true;
      ExtensionPage_RestoreInput_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPage::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RestoreInput(        );
      return true;
    }
    case messages::ExtensionPage::kEnterBasicMode: {
      DCHECK(message->is_serialized());
      internal::ExtensionPage_EnterBasicMode_Params_Data* params =
          reinterpret_cast<internal::ExtensionPage_EnterBasicMode_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ExtensionPage.4
      bool success = true;
      ExtensionPage_EnterBasicMode_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPage::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->EnterBasicMode(        );
      return true;
    }
    case messages::ExtensionPage::kExitBasicMode: {
      DCHECK(message->is_serialized());
      internal::ExtensionPage_ExitBasicMode_Params_Data* params =
          reinterpret_cast<internal::ExtensionPage_ExitBasicMode_Params_Data*>(
              message->mutable_payload());
      

      // Validation for ExtensionPage.5
      bool success = true;
      ExtensionPage_ExitBasicMode_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            ExtensionPage::Name_, 5, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ExitBasicMode(        );
      return true;
    }
    case messages::ExtensionPage::kLockInput: {
      DCHECK(message->is_serialized());
      internal::ExtensionPage_LockInput_Params_Data* params =
          reinterpret_cast<internal::ExtensionPage_LockInput_Params_Data*>(
              message->mutable_payload());
      

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

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

// static
bool ExtensionPageStubDispatch::AcceptWithResponder(
    ExtensionPage* 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::ExtensionPage>(message->header()->name)) {
    case messages::ExtensionPage::kPostAimMessage: {
      break;
    }
    case messages::ExtensionPage::kOnHandshakeComplete: {
      break;
    }
    case messages::ExtensionPage::kHideInput: {
      break;
    }
    case messages::ExtensionPage::kRestoreInput: {
      break;
    }
    case messages::ExtensionPage::kEnterBasicMode: {
      break;
    }
    case messages::ExtensionPage::kExitBasicMode: {
      break;
    }
    case messages::ExtensionPage::kLockInput: {
      break;
    }
    case messages::ExtensionPage::kUnlockInput: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kExtensionPageValidationInfo[] = {
    { &internal::ExtensionPage_PostAimMessage_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_OnHandshakeComplete_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_HideInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_RestoreInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_EnterBasicMode_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_ExitBasicMode_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_LockInput_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::ExtensionPage_UnlockInput_Params_Data::Validate,
     nullptr /* no response */},
};

bool ExtensionPageRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::contextual_tasks::mojom::ExtensionPage::Name_,
    kExtensionPageValidationInfo);
}



}  // contextual_tasks::mojom


namespace mojo {


// static
bool StructTraits<::contextual_tasks::mojom::InjectedInput::DataView, ::contextual_tasks::mojom::InjectedInputPtr>::Read(
    ::contextual_tasks::mojom::InjectedInput::DataView input,
    ::contextual_tasks::mojom::InjectedInputPtr* output) {
  bool success = true;
  ::contextual_tasks::mojom::InjectedInputPtr result(::contextual_tasks::mojom::InjectedInput::New());
  
      if (success && !input.ReadTitle(&result->title))
        success = false;
      if (success && !input.ReadThumbnail(&result->thumbnail))
        success = false;
      if (success && !input.ReadIconId(&result->icon_id))
        success = false;
      if (success && !input.ReadFileToken(&result->file_token))
        success = false;
      if (success)
        result->supports_unimodal = input.supports_unimodal();
      if (success && !input.ReadQueryText(&result->query_text))
        success = false;
      if (success)
        result->submit_after_injection = input.submit_after_injection();
  *output = std::move(result);
  return success;
}


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


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


// static
bool StructTraits<::contextual_tasks::mojom::TabContext::DataView, ::contextual_tasks::mojom::TabContextPtr>::Read(
    ::contextual_tasks::mojom::TabContext::DataView input,
    ::contextual_tasks::mojom::TabContextPtr* output) {
  bool success = true;
  ::contextual_tasks::mojom::TabContextPtr result(::contextual_tasks::mojom::TabContext::New());
  
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadTitle(&result->title))
        success = false;
      if (success)
        result->tab_id = input.tab_id();
      if (success)
        result->has_chrome_tab_data = input.has_chrome_tab_data();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::contextual_tasks::mojom::ImageContext::DataView, ::contextual_tasks::mojom::ImageContextPtr>::Read(
    ::contextual_tasks::mojom::ImageContext::DataView input,
    ::contextual_tasks::mojom::ImageContextPtr* output) {
  bool success = true;
  ::contextual_tasks::mojom::ImageContextPtr result(::contextual_tasks::mojom::ImageContext::New());
  
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadTitle(&result->title))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::contextual_tasks::mojom::FileContext::DataView, ::contextual_tasks::mojom::FileContextPtr>::Read(
    ::contextual_tasks::mojom::FileContext::DataView input,
    ::contextual_tasks::mojom::FileContextPtr* output) {
  bool success = true;
  ::contextual_tasks::mojom::FileContextPtr result(::contextual_tasks::mojom::FileContext::New());
  
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadTitle(&result->title))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::contextual_tasks::mojom::ComposeboxPosition::DataView, ::contextual_tasks::mojom::ComposeboxPositionPtr>::Read(
    ::contextual_tasks::mojom::ComposeboxPosition::DataView input,
    ::contextual_tasks::mojom::ComposeboxPositionPtr* output) {
  bool success = true;
  ::contextual_tasks::mojom::ComposeboxPositionPtr result(::contextual_tasks::mojom::ComposeboxPosition::New());
  
      if (success) {
        result->max_width = input.max_width();
      }
      if (success) {
        result->max_height = input.max_height();
      }
      if (success) {
        result->margin_bottom = input.margin_bottom();
      }
      if (success) {
        result->margin_left = input.margin_left();
      }
  *output = std::move(result);
  return success;
}

// static
bool UnionTraits<::contextual_tasks::mojom::ContextInfo::DataView, ::contextual_tasks::mojom::ContextInfoPtr>::Read(
    ::contextual_tasks::mojom::ContextInfo::DataView input,
    ::contextual_tasks::mojom::ContextInfoPtr* output) {
  using UnionType = ::contextual_tasks::mojom::ContextInfo;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kTab: {
      ::contextual_tasks::mojom::TabContextPtr result_tab{};
      if (!input.ReadTab(&result_tab))
        return false;

      *output = UnionType::NewTab(
          std::move(result_tab));
      break;
    }
    case Tag::kImage: {
      ::contextual_tasks::mojom::ImageContextPtr result_image{};
      if (!input.ReadImage(&result_image))
        return false;

      *output = UnionType::NewImage(
          std::move(result_image));
      break;
    }
    case Tag::kFile: {
      ::contextual_tasks::mojom::FileContextPtr result_file{};
      if (!input.ReadFile(&result_file))
        return false;

      *output = UnionType::NewFile(
          std::move(result_file));
      break;
    }
    default:

      return false;
  }
  return true;
}

}  // namespace mojo


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


namespace contextual_tasks::mojom {


void PageHandlerInterceptorForTesting::GetThreadUrl(GetThreadUrlCallback callback) {
  GetForwardingInterface()->GetThreadUrl(std::move(callback));
}
void PageHandlerInterceptorForTesting::GetUrlForTask(const ::base::Uuid& uuid, GetUrlForTaskCallback callback) {
  GetForwardingInterface()->GetUrlForTask(
    std::move(uuid)
    , std::move(callback));
}
void PageHandlerInterceptorForTesting::SetTaskId(const ::base::Uuid& uuid) {
  GetForwardingInterface()->SetTaskId(
    std::move(uuid)
    );
}
void PageHandlerInterceptorForTesting::IsZeroState(const ::GURL& url, IsZeroStateCallback callback) {
  GetForwardingInterface()->IsZeroState(
    std::move(url)
    , std::move(callback));
}
void PageHandlerInterceptorForTesting::IsAiPage(const ::GURL& url, IsAiPageCallback callback) {
  GetForwardingInterface()->IsAiPage(
    std::move(url)
    , std::move(callback));
}
void PageHandlerInterceptorForTesting::IsPendingErrorPage(const ::base::Uuid& task_id, IsPendingErrorPageCallback callback) {
  GetForwardingInterface()->IsPendingErrorPage(
    std::move(task_id)
    , std::move(callback));
}
void PageHandlerInterceptorForTesting::IsEmbeddedPageErrorDocument(IsEmbeddedPageErrorDocumentCallback callback) {
  GetForwardingInterface()->IsEmbeddedPageErrorDocument(std::move(callback));
}
void PageHandlerInterceptorForTesting::SetThreadTitle(const std::string& title) {
  GetForwardingInterface()->SetThreadTitle(
    std::move(title)
    );
}
void PageHandlerInterceptorForTesting::CloseSidePanel() {
  GetForwardingInterface()->CloseSidePanel();
}
void PageHandlerInterceptorForTesting::ShowThreadHistory() {
  GetForwardingInterface()->ShowThreadHistory();
}
void PageHandlerInterceptorForTesting::IsShownInTab(IsShownInTabCallback callback) {
  GetForwardingInterface()->IsShownInTab(std::move(callback));
}
void PageHandlerInterceptorForTesting::OpenMyActivityUi() {
  GetForwardingInterface()->OpenMyActivityUi();
}
void PageHandlerInterceptorForTesting::OpenFeedbackUi() {
  GetForwardingInterface()->OpenFeedbackUi();
}
void PageHandlerInterceptorForTesting::OpenOnboardingHelpUi() {
  GetForwardingInterface()->OpenOnboardingHelpUi();
}
void PageHandlerInterceptorForTesting::OpenOverflowMenuHelpUi() {
  GetForwardingInterface()->OpenOverflowMenuHelpUi();
}
void PageHandlerInterceptorForTesting::OpenUrl(const ::GURL& url, ::WindowOpenDisposition disposition) {
  GetForwardingInterface()->OpenUrl(
    std::move(url)
    , 
    std::move(disposition)
    );
}
void PageHandlerInterceptorForTesting::MoveTaskUiToNewTab() {
  GetForwardingInterface()->MoveTaskUiToNewTab();
}
void PageHandlerInterceptorForTesting::OnTabClickedFromSourcesMenu(int32_t tab_id, const ::GURL& url) {
  GetForwardingInterface()->OnTabClickedFromSourcesMenu(
    std::move(tab_id)
    , 
    std::move(url)
    );
}
void PageHandlerInterceptorForTesting::OnFileClickedFromSourcesMenu(const ::GURL& url) {
  GetForwardingInterface()->OnFileClickedFromSourcesMenu(
    std::move(url)
    );
}
void PageHandlerInterceptorForTesting::OnImageClickedFromSourcesMenu(const ::GURL& url) {
  GetForwardingInterface()->OnImageClickedFromSourcesMenu(
    std::move(url)
    );
}
void PageHandlerInterceptorForTesting::OnWebviewMessage(const std::vector<uint8_t>& message) {
  GetForwardingInterface()->OnWebviewMessage(
    std::move(message)
    );
}
void PageHandlerInterceptorForTesting::GetCommonSearchParams(bool is_dark_mode, bool is_side_panel, GetCommonSearchParamsCallback callback) {
  GetForwardingInterface()->GetCommonSearchParams(
    std::move(is_dark_mode)
    , 
    std::move(is_side_panel)
    , std::move(callback));
}
void PageHandlerInterceptorForTesting::OnboardingTooltipDismissed() {
  GetForwardingInterface()->OnboardingTooltipDismissed();
}
void PageHandlerInterceptorForTesting::LensSearchTooltipDismissed() {
  GetForwardingInterface()->LensSearchTooltipDismissed();
}
void PageHandlerInterceptorForTesting::AskGTooltipDismissed() {
  GetForwardingInterface()->AskGTooltipDismissed();
}
void PageHandlerInterceptorForTesting::ReopenTabs() {
  GetForwardingInterface()->ReopenTabs();
}
void PageHandlerInterceptorForTesting::PinSidePanel() {
  GetForwardingInterface()->PinSidePanel();
}
void PageHandlerInterceptorForTesting::UnpinSidePanel() {
  GetForwardingInterface()->UnpinSidePanel();
}
void PageHandlerInterceptorForTesting::OnContextMenuOpened() {
  GetForwardingInterface()->OnContextMenuOpened();
}
void PageHandlerInterceptorForTesting::NotifySmartTabSharingTryItIphResult(bool accepted) {
  GetForwardingInterface()->NotifySmartTabSharingTryItIphResult(
    std::move(accepted)
    );
}
void PageHandlerInterceptorForTesting::NotifySmartTabSharingDefaultOnIphResult(bool accepted) {
  GetForwardingInterface()->NotifySmartTabSharingDefaultOnIphResult(
    std::move(accepted)
    );
}
void PageHandlerInterceptorForTesting::RegisterWindow(const ::contextual_tasks::ContextualTaskId& task_id, const ::GURL& url, const ::contextual_tasks::ContextualWindowId& window_id) {
  GetForwardingInterface()->RegisterWindow(
    std::move(task_id)
    , 
    std::move(url)
    , 
    std::move(window_id)
    );
}
void PageHandlerInterceptorForTesting::CloseWindow(const ::contextual_tasks::ContextualWindowId& window_id) {
  GetForwardingInterface()->CloseWindow(
    std::move(window_id)
    );
}
void PageHandlerInterceptorForTesting::MaybeTriggerPinningPromo() {
  GetForwardingInterface()->MaybeTriggerPinningPromo();
}
void PageHandlerInterceptorForTesting::ShowPageInfoBubble(bool is_pointer_interaction) {
  GetForwardingInterface()->ShowPageInfoBubble(
    std::move(is_pointer_interaction)
    );
}
void PageHandlerInterceptorForTesting::OnLogoPointerDown() {
  GetForwardingInterface()->OnLogoPointerDown();
}
void PageHandlerInterceptorForTesting::CreateNewThread() {
  GetForwardingInterface()->CreateNewThread();
}
PageHandlerAsyncWaiter::PageHandlerAsyncWaiter(
    PageHandler* proxy) : proxy_(proxy) {}

PageHandlerAsyncWaiter::~PageHandlerAsyncWaiter() = default;


void PageHandlerAsyncWaiter::GetThreadUrl(
    ::GURL* out_url) {
  base::RunLoop loop;
  proxy_->GetThreadUrl(
      base::BindOnce(
          [](base::RunLoop* loop,
             ::GURL* out_url
,
             const ::GURL& url) {*out_url = std::move(url);
            loop->Quit();
          },
          &loop,
          out_url));
  loop.Run();
}

::GURL PageHandlerAsyncWaiter::GetThreadUrl(
    ) {
  ::GURL async_wait_result;
  GetThreadUrl(&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::GetUrlForTask(
    const ::base::Uuid& uuid, ::GURL* out_url) {
  base::RunLoop loop;
  proxy_->GetUrlForTask(
      std::move(uuid),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::GURL* out_url
,
             const ::GURL& url) {*out_url = std::move(url);
            loop->Quit();
          },
          &loop,
          out_url));
  loop.Run();
}

::GURL PageHandlerAsyncWaiter::GetUrlForTask(
    const ::base::Uuid& uuid) {
  ::GURL async_wait_result;
  GetUrlForTask(std::move(uuid),&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::IsZeroState(
    const ::GURL& url, bool* out_is_zero_state) {
  base::RunLoop loop;
  proxy_->IsZeroState(
      std::move(url),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_zero_state
,
             bool is_zero_state) {*out_is_zero_state = std::move(is_zero_state);
            loop->Quit();
          },
          &loop,
          out_is_zero_state));
  loop.Run();
}

bool PageHandlerAsyncWaiter::IsZeroState(
    const ::GURL& url) {
  bool async_wait_result;
  IsZeroState(std::move(url),&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::IsAiPage(
    const ::GURL& url, bool* out_is_ai_page) {
  base::RunLoop loop;
  proxy_->IsAiPage(
      std::move(url),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_ai_page
,
             bool is_ai_page) {*out_is_ai_page = std::move(is_ai_page);
            loop->Quit();
          },
          &loop,
          out_is_ai_page));
  loop.Run();
}

bool PageHandlerAsyncWaiter::IsAiPage(
    const ::GURL& url) {
  bool async_wait_result;
  IsAiPage(std::move(url),&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::IsPendingErrorPage(
    const ::base::Uuid& task_id, bool* out_is_pending_error_page) {
  base::RunLoop loop;
  proxy_->IsPendingErrorPage(
      std::move(task_id),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_pending_error_page
,
             bool is_pending_error_page) {*out_is_pending_error_page = std::move(is_pending_error_page);
            loop->Quit();
          },
          &loop,
          out_is_pending_error_page));
  loop.Run();
}

bool PageHandlerAsyncWaiter::IsPendingErrorPage(
    const ::base::Uuid& task_id) {
  bool async_wait_result;
  IsPendingErrorPage(std::move(task_id),&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::IsEmbeddedPageErrorDocument(
    bool* out_is_error_document) {
  base::RunLoop loop;
  proxy_->IsEmbeddedPageErrorDocument(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_error_document
,
             bool is_error_document) {*out_is_error_document = std::move(is_error_document);
            loop->Quit();
          },
          &loop,
          out_is_error_document));
  loop.Run();
}

bool PageHandlerAsyncWaiter::IsEmbeddedPageErrorDocument(
    ) {
  bool async_wait_result;
  IsEmbeddedPageErrorDocument(&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::IsShownInTab(
    bool* out_is_in_tab) {
  base::RunLoop loop;
  proxy_->IsShownInTab(
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_is_in_tab
,
             bool is_in_tab) {*out_is_in_tab = std::move(is_in_tab);
            loop->Quit();
          },
          &loop,
          out_is_in_tab));
  loop.Run();
}

bool PageHandlerAsyncWaiter::IsShownInTab(
    ) {
  bool async_wait_result;
  IsShownInTab(&async_wait_result);
  return async_wait_result;
}

void PageHandlerAsyncWaiter::GetCommonSearchParams(
    bool is_dark_mode, bool is_side_panel, base::flat_map<std::string, std::string>* out_params) {
  base::RunLoop loop;
  proxy_->GetCommonSearchParams(
      std::move(is_dark_mode),
      std::move(is_side_panel),
      base::BindOnce(
          [](base::RunLoop* loop,
             base::flat_map<std::string, std::string>* out_params
,
             const base::flat_map<std::string, std::string>& params) {*out_params = std::move(params);
            loop->Quit();
          },
          &loop,
          out_params));
  loop.Run();
}

base::flat_map<std::string, std::string> PageHandlerAsyncWaiter::GetCommonSearchParams(
    bool is_dark_mode, bool is_side_panel) {
  base::flat_map<std::string, std::string> async_wait_result;
  GetCommonSearchParams(std::move(is_dark_mode),std::move(is_side_panel),&async_wait_result);
  return async_wait_result;
}




void PageInterceptorForTesting::SetThreadTitle(const std::string& title) {
  GetForwardingInterface()->SetThreadTitle(
    std::move(title)
    );
}
void PageInterceptorForTesting::SetTaskDetails(const ::base::Uuid& uuid, const ::GURL& url, bool replace_navigation_entry) {
  GetForwardingInterface()->SetTaskDetails(
    std::move(uuid)
    , 
    std::move(url)
    , 
    std::move(replace_navigation_entry)
    );
}
void PageInterceptorForTesting::OnSidePanelStateChanged() {
  GetForwardingInterface()->OnSidePanelStateChanged();
}
void PageInterceptorForTesting::PostAimMessage(const std::vector<uint8_t>& message) {
  GetForwardingInterface()->PostAimMessage(
    std::move(message)
    );
}
void PageInterceptorForTesting::OnHandshakeComplete() {
  GetForwardingInterface()->OnHandshakeComplete();
}
void PageInterceptorForTesting::SetOAuthToken(const std::string& oauth_token) {
  GetForwardingInterface()->SetOAuthToken(
    std::move(oauth_token)
    );
}
void PageInterceptorForTesting::OnCookieSyncCompleted() {
  GetForwardingInterface()->OnCookieSyncCompleted();
}
void PageInterceptorForTesting::OnContextUpdated(std::vector<ContextInfoPtr> context) {
  GetForwardingInterface()->OnContextUpdated(
    std::move(context)
    );
}
void PageInterceptorForTesting::HideInput() {
  GetForwardingInterface()->HideInput();
}
void PageInterceptorForTesting::RestoreInput() {
  GetForwardingInterface()->RestoreInput();
}
void PageInterceptorForTesting::EnterBasicMode() {
  GetForwardingInterface()->EnterBasicMode();
}
void PageInterceptorForTesting::ExitBasicMode() {
  GetForwardingInterface()->ExitBasicMode();
}
void PageInterceptorForTesting::InjectInput(InjectedInputPtr input) {
  GetForwardingInterface()->InjectInput(
    std::move(input)
    );
}
void PageInterceptorForTesting::RemoveInjectedInput(const ::base::UnguessableToken& file_token) {
  GetForwardingInterface()->RemoveInjectedInput(
    std::move(file_token)
    );
}
void PageInterceptorForTesting::OnZeroStateChange(bool is_zero_state) {
  GetForwardingInterface()->OnZeroStateChange(
    std::move(is_zero_state)
    );
}
void PageInterceptorForTesting::SetInNlm(bool in_nlm) {
  GetForwardingInterface()->SetInNlm(
    std::move(in_nlm)
    );
}
void PageInterceptorForTesting::OnAiPageStatusChanged(bool is_ai_page) {
  GetForwardingInterface()->OnAiPageStatusChanged(
    std::move(is_ai_page)
    );
}
void PageInterceptorForTesting::OnLensOverlayStateChanged(bool is_showing, bool maybe_show_overlay_hint_text) {
  GetForwardingInterface()->OnLensOverlayStateChanged(
    std::move(is_showing)
    , 
    std::move(maybe_show_overlay_hint_text)
    );
}
void PageInterceptorForTesting::ShowErrorPage() {
  GetForwardingInterface()->ShowErrorPage();
}
void PageInterceptorForTesting::HideErrorPage() {
  GetForwardingInterface()->HideErrorPage();
}
void PageInterceptorForTesting::ShowOauthErrorDialog() {
  GetForwardingInterface()->ShowOauthErrorDialog();
}
void PageInterceptorForTesting::UpdateComposeboxPosition(ComposeboxPositionPtr position) {
  GetForwardingInterface()->UpdateComposeboxPosition(
    std::move(position)
    );
}
void PageInterceptorForTesting::LockInput() {
  GetForwardingInterface()->LockInput();
}
void PageInterceptorForTesting::UnlockInput() {
  GetForwardingInterface()->UnlockInput();
}
void PageInterceptorForTesting::SetShowReopenTabs(bool show) {
  GetForwardingInterface()->SetShowReopenTabs(
    std::move(show)
    );
}
void PageInterceptorForTesting::OnSidePanelPinStateChanged(bool is_pinned) {
  GetForwardingInterface()->OnSidePanelPinStateChanged(
    std::move(is_pinned)
    );
}
void PageInterceptorForTesting::SetExpandButtonEnabled(bool enabled) {
  GetForwardingInterface()->SetExpandButtonEnabled(
    std::move(enabled)
    );
}
void PageInterceptorForTesting::TurnOnSmartTabSharing() {
  GetForwardingInterface()->TurnOnSmartTabSharing();
}
void PageInterceptorForTesting::ShowSmartTabSharingTryItIph() {
  GetForwardingInterface()->ShowSmartTabSharingTryItIph();
}
void PageInterceptorForTesting::ShowSmartTabSharingDefaultOnIph() {
  GetForwardingInterface()->ShowSmartTabSharingDefaultOnIph();
}
void PageInterceptorForTesting::OnWindowClosed(const ::contextual_tasks::ContextualWindowId& window_id) {
  GetForwardingInterface()->OnWindowClosed(
    std::move(window_id)
    );
}
PageAsyncWaiter::PageAsyncWaiter(
    Page* proxy) : proxy_(proxy) {}

PageAsyncWaiter::~PageAsyncWaiter() = default;





void PageHandlerFactoryInterceptorForTesting::CreatePageHandler(::mojo::PendingRemote<Page> page, ::mojo::PendingReceiver<PageHandler> page_handler) {
  GetForwardingInterface()->CreatePageHandler(
    std::move(page)
    , 
    std::move(page_handler)
    );
}
PageHandlerFactoryAsyncWaiter::PageHandlerFactoryAsyncWaiter(
    PageHandlerFactory* proxy) : proxy_(proxy) {}

PageHandlerFactoryAsyncWaiter::~PageHandlerFactoryAsyncWaiter() = default;





void ExtensionPageHandlerFactoryInterceptorForTesting::CreateExtensionPageHandler(::mojo::PendingRemote<ExtensionPage> page, ::mojo::PendingReceiver<ExtensionPageHandler> receiver) {
  GetForwardingInterface()->CreateExtensionPageHandler(
    std::move(page)
    , 
    std::move(receiver)
    );
}
ExtensionPageHandlerFactoryAsyncWaiter::ExtensionPageHandlerFactoryAsyncWaiter(
    ExtensionPageHandlerFactory* proxy) : proxy_(proxy) {}

ExtensionPageHandlerFactoryAsyncWaiter::~ExtensionPageHandlerFactoryAsyncWaiter() = default;





void ExtensionPageHandlerInterceptorForTesting::GetHandshakeMessage(GetHandshakeMessageCallback callback) {
  GetForwardingInterface()->GetHandshakeMessage(std::move(callback));
}
void ExtensionPageHandlerInterceptorForTesting::OnWebviewMessage(const std::vector<uint8_t>& message) {
  GetForwardingInterface()->OnWebviewMessage(
    std::move(message)
    );
}
void ExtensionPageHandlerInterceptorForTesting::SetTaskId(const ::base::Uuid& uuid) {
  GetForwardingInterface()->SetTaskId(
    std::move(uuid)
    );
}
ExtensionPageHandlerAsyncWaiter::ExtensionPageHandlerAsyncWaiter(
    ExtensionPageHandler* proxy) : proxy_(proxy) {}

ExtensionPageHandlerAsyncWaiter::~ExtensionPageHandlerAsyncWaiter() = default;


void ExtensionPageHandlerAsyncWaiter::GetHandshakeMessage(
    ::mojo_base::ProtoWrapper* out_message) {
  base::RunLoop loop;
  proxy_->GetHandshakeMessage(
      base::BindOnce(
          [](base::RunLoop* loop,
             ::mojo_base::ProtoWrapper* out_message
,
             ::mojo_base::ProtoWrapper message) {*out_message = std::move(message);
            loop->Quit();
          },
          &loop,
          out_message));
  loop.Run();
}

::mojo_base::ProtoWrapper ExtensionPageHandlerAsyncWaiter::GetHandshakeMessage(
    ) {
  ::mojo_base::ProtoWrapper async_wait_result{mojo::internal::DefaultConstructTag()};
  GetHandshakeMessage(&async_wait_result);
  return async_wait_result;
}




void ExtensionPageInterceptorForTesting::PostAimMessage(const std::vector<uint8_t>& message) {
  GetForwardingInterface()->PostAimMessage(
    std::move(message)
    );
}
void ExtensionPageInterceptorForTesting::OnHandshakeComplete() {
  GetForwardingInterface()->OnHandshakeComplete();
}
void ExtensionPageInterceptorForTesting::HideInput() {
  GetForwardingInterface()->HideInput();
}
void ExtensionPageInterceptorForTesting::RestoreInput() {
  GetForwardingInterface()->RestoreInput();
}
void ExtensionPageInterceptorForTesting::EnterBasicMode() {
  GetForwardingInterface()->EnterBasicMode();
}
void ExtensionPageInterceptorForTesting::ExitBasicMode() {
  GetForwardingInterface()->ExitBasicMode();
}
void ExtensionPageInterceptorForTesting::LockInput() {
  GetForwardingInterface()->LockInput();
}
void ExtensionPageInterceptorForTesting::UnlockInput() {
  GetForwardingInterface()->UnlockInput();
}
ExtensionPageAsyncWaiter::ExtensionPageAsyncWaiter(
    ExtensionPage* proxy) : proxy_(proxy) {}

ExtensionPageAsyncWaiter::~ExtensionPageAsyncWaiter() = default;







}  // contextual_tasks::mojom


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