compose.mojom.cc | Explore in Territory

// chrome/common/compose/compose.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/common/compose/compose.mojom.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.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/features.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_util.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/common/compose/compose.mojom-params-data.h"
#include "chrome/common/compose/compose.mojom-shared-message-ids.h"

#include "chrome/common/compose/compose.mojom-import-headers.h"
#include "chrome/common/compose/compose.mojom-test-utils.h"


namespace compose::mojom {
ComposeResponse::ComposeResponse()
    : … { … }

ComposeResponse::ComposeResponse(
    ::compose::mojom::ComposeStatus status_in,
    const std::string& result_in,
    bool undo_available_in,
    bool redo_available_in,
    bool provided_by_user_in,
    bool on_device_evaluation_used_in,
    bool triggered_from_modifier_in)
    : … { … }

ComposeResponse::~ComposeResponse() = default;
size_t ComposeResponse::Hash(size_t seed) const { … }

void ComposeResponse::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ComposeResponse::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PartialComposeResponse::PartialComposeResponse()
    : … { … }

PartialComposeResponse::PartialComposeResponse(
    const std::string& result_in)
    : … { … }

PartialComposeResponse::~PartialComposeResponse() = default;
size_t PartialComposeResponse::Hash(size_t seed) const { … }

void PartialComposeResponse::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PartialComposeResponse::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ComposeState::ComposeState()
    : … { … }

ComposeState::ComposeState(
    const std::string& webui_state_in,
    ComposeResponsePtr response_in,
    bool has_pending_request_in,
    UserFeedback feedback_in)
    : … { … }

ComposeState::~ComposeState() = default;

void ComposeState::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ComposeState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ConfigurableParams::ConfigurableParams()
    : … { … }

ConfigurableParams::ConfigurableParams(
    int32_t min_word_limit_in,
    int32_t max_word_limit_in,
    int32_t max_character_limit_in)
    : … { … }

ConfigurableParams::~ConfigurableParams() = default;
size_t ConfigurableParams::Hash(size_t seed) const { … }

void ConfigurableParams::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ConfigurableParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
OpenMetadata::OpenMetadata()
    : … { … }

OpenMetadata::OpenMetadata(
    bool fre_complete_in,
    bool msbb_state_in,
    const std::string& initial_input_in,
    bool text_selected_in,
    ComposeStatePtr compose_state_in,
    ConfigurableParamsPtr configurable_params_in)
    : … { … }

OpenMetadata::~OpenMetadata() = default;

void OpenMetadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool OpenMetadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char ComposeSessionUntrustedPageHandlerFactory::Name_[] = …;

ComposeSessionUntrustedPageHandlerFactory::IPCStableHashFunction ComposeSessionUntrustedPageHandlerFactory::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ComposeSessionUntrustedPageHandlerFactory::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ComposeSessionUntrustedPageHandlerFactory::CreateComposeSessionUntrustedPageHandler_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

ComposeSessionUntrustedPageHandlerFactoryProxy::ComposeSessionUntrustedPageHandlerFactoryProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void ComposeSessionUntrustedPageHandlerFactoryProxy::CreateComposeSessionUntrustedPageHandler(
    ::mojo::PendingReceiver<ComposeClientUntrustedPageHandler> in_client_handler, ::mojo::PendingReceiver<ComposeSessionUntrustedPageHandler> in_handler, ::mojo::PendingRemote<ComposeUntrustedDialog> in_dialog) { … }

// static
bool ComposeSessionUntrustedPageHandlerFactoryStubDispatch::Accept(
    ComposeSessionUntrustedPageHandlerFactory* impl,
    mojo::Message* message) { … }

// static
bool ComposeSessionUntrustedPageHandlerFactoryStubDispatch::AcceptWithResponder(
    ComposeSessionUntrustedPageHandlerFactory* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kComposeSessionUntrustedPageHandlerFactoryValidationInfo[] = …;

bool ComposeSessionUntrustedPageHandlerFactoryRequestValidator::Accept(mojo::Message* message) { … }

const char ComposeSessionUntrustedPageHandler::Name_[] = …;

ComposeSessionUntrustedPageHandler::IPCStableHashFunction ComposeSessionUntrustedPageHandler::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ComposeSessionUntrustedPageHandler::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ComposeSessionUntrustedPageHandler::LogCancelEdit_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::Compose_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::Rewrite_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::LogEditInput_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::SaveWebUIState_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::AcceptComposeResult_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::RequestInitialState_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::Undo_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::RecoverFromErrorState_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::Redo_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::OpenBugReportingLink_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::OpenComposeLearnMorePage_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::OpenFeedbackSurveyLink_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::OpenSignInPage_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::SetUserFeedback_Sym::IPCStableHash() { … }
uint32_t ComposeSessionUntrustedPageHandler::EditResult_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class ComposeSessionUntrustedPageHandler_AcceptComposeResult_ForwardToCallback
    : public mojo::MessageReceiver { … };

class ComposeSessionUntrustedPageHandler_RequestInitialState_ForwardToCallback
    : public mojo::MessageReceiver { … };

class ComposeSessionUntrustedPageHandler_Undo_ForwardToCallback
    : public mojo::MessageReceiver { … };

class ComposeSessionUntrustedPageHandler_RecoverFromErrorState_ForwardToCallback
    : public mojo::MessageReceiver { … };

class ComposeSessionUntrustedPageHandler_Redo_ForwardToCallback
    : public mojo::MessageReceiver { … };

class ComposeSessionUntrustedPageHandler_EditResult_ForwardToCallback
    : public mojo::MessageReceiver { … };

ComposeSessionUntrustedPageHandlerProxy::ComposeSessionUntrustedPageHandlerProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void ComposeSessionUntrustedPageHandlerProxy::LogCancelEdit(
    ) { … }

void ComposeSessionUntrustedPageHandlerProxy::Compose(
    const std::string& in_input, bool in_edited) { … }

void ComposeSessionUntrustedPageHandlerProxy::Rewrite(
    StyleModifier in_style) { … }

void ComposeSessionUntrustedPageHandlerProxy::LogEditInput(
    ) { … }

void ComposeSessionUntrustedPageHandlerProxy::SaveWebUIState(
    const std::string& in_webui_state) { … }

void ComposeSessionUntrustedPageHandlerProxy::AcceptComposeResult(
    AcceptComposeResultCallback callback) { … }

void ComposeSessionUntrustedPageHandlerProxy::RequestInitialState(
    RequestInitialStateCallback callback) { … }

void ComposeSessionUntrustedPageHandlerProxy::Undo(
    UndoCallback callback) { … }

void ComposeSessionUntrustedPageHandlerProxy::RecoverFromErrorState(
    RecoverFromErrorStateCallback callback) { … }

void ComposeSessionUntrustedPageHandlerProxy::Redo(
    RedoCallback callback) { … }

void ComposeSessionUntrustedPageHandlerProxy::OpenBugReportingLink(
    ) { … }

void ComposeSessionUntrustedPageHandlerProxy::OpenComposeLearnMorePage(
    ) { … }

void ComposeSessionUntrustedPageHandlerProxy::OpenFeedbackSurveyLink(
    ) { … }

void ComposeSessionUntrustedPageHandlerProxy::OpenSignInPage(
    ) { … }

void ComposeSessionUntrustedPageHandlerProxy::SetUserFeedback(
    UserFeedback in_feedback) { … }

void ComposeSessionUntrustedPageHandlerProxy::EditResult(
    const std::string& in_new_result, EditResultCallback callback) { … }
class ComposeSessionUntrustedPageHandler_AcceptComposeResult_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ComposeSessionUntrustedPageHandler_AcceptComposeResult_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ComposeSessionUntrustedPageHandler_AcceptComposeResult_ProxyToResponder::Run(
    bool in_success) { … }
class ComposeSessionUntrustedPageHandler_RequestInitialState_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ComposeSessionUntrustedPageHandler_RequestInitialState_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ComposeSessionUntrustedPageHandler_RequestInitialState_ProxyToResponder::Run(
    OpenMetadataPtr in_initial_state) { … }
class ComposeSessionUntrustedPageHandler_Undo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ComposeSessionUntrustedPageHandler_Undo_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ComposeSessionUntrustedPageHandler_Undo_ProxyToResponder::Run(
    ComposeStatePtr in_last_state) { … }
class ComposeSessionUntrustedPageHandler_RecoverFromErrorState_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ComposeSessionUntrustedPageHandler_RecoverFromErrorState_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ComposeSessionUntrustedPageHandler_RecoverFromErrorState_ProxyToResponder::Run(
    ComposeStatePtr in_state_before_error) { … }
class ComposeSessionUntrustedPageHandler_Redo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ComposeSessionUntrustedPageHandler_Redo_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ComposeSessionUntrustedPageHandler_Redo_ProxyToResponder::Run(
    ComposeStatePtr in_next_state) { … }
class ComposeSessionUntrustedPageHandler_EditResult_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool ComposeSessionUntrustedPageHandler_EditResult_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void ComposeSessionUntrustedPageHandler_EditResult_ProxyToResponder::Run(
    bool in_is_edited) { … }

// static
bool ComposeSessionUntrustedPageHandlerStubDispatch::Accept(
    ComposeSessionUntrustedPageHandler* impl,
    mojo::Message* message) { … }

// static
bool ComposeSessionUntrustedPageHandlerStubDispatch::AcceptWithResponder(
    ComposeSessionUntrustedPageHandler* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kComposeSessionUntrustedPageHandlerValidationInfo[] = …;

bool ComposeSessionUntrustedPageHandlerRequestValidator::Accept(mojo::Message* message) { … }

bool ComposeSessionUntrustedPageHandlerResponseValidator::Accept(mojo::Message* message) { … }
const char ComposeClientUntrustedPageHandler::Name_[] = …;

ComposeClientUntrustedPageHandler::IPCStableHashFunction ComposeClientUntrustedPageHandler::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ComposeClientUntrustedPageHandler::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ComposeClientUntrustedPageHandler::ShowUI_Sym::IPCStableHash() { … }
uint32_t ComposeClientUntrustedPageHandler::CloseUI_Sym::IPCStableHash() { … }
uint32_t ComposeClientUntrustedPageHandler::CompleteFirstRun_Sym::IPCStableHash() { … }
uint32_t ComposeClientUntrustedPageHandler::OpenComposeSettings_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

ComposeClientUntrustedPageHandlerProxy::ComposeClientUntrustedPageHandlerProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void ComposeClientUntrustedPageHandlerProxy::ShowUI(
    ) { … }

void ComposeClientUntrustedPageHandlerProxy::CloseUI(
    CloseReason in_reason) { … }

void ComposeClientUntrustedPageHandlerProxy::CompleteFirstRun(
    ) { … }

void ComposeClientUntrustedPageHandlerProxy::OpenComposeSettings(
    ) { … }

// static
bool ComposeClientUntrustedPageHandlerStubDispatch::Accept(
    ComposeClientUntrustedPageHandler* impl,
    mojo::Message* message) { … }

// static
bool ComposeClientUntrustedPageHandlerStubDispatch::AcceptWithResponder(
    ComposeClientUntrustedPageHandler* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kComposeClientUntrustedPageHandlerValidationInfo[] = …;

bool ComposeClientUntrustedPageHandlerRequestValidator::Accept(mojo::Message* message) { … }

const char ComposeUntrustedDialog::Name_[] = …;

ComposeUntrustedDialog::IPCStableHashFunction ComposeUntrustedDialog::MessageToMethodInfo_(mojo::Message& message) { … }


const char* ComposeUntrustedDialog::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ComposeUntrustedDialog::ResponseReceived_Sym::IPCStableHash() { … }
uint32_t ComposeUntrustedDialog::PartialResponseReceived_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

ComposeUntrustedDialogProxy::ComposeUntrustedDialogProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void ComposeUntrustedDialogProxy::ResponseReceived(
    ComposeResponsePtr in_response) { … }

void ComposeUntrustedDialogProxy::PartialResponseReceived(
    PartialComposeResponsePtr in_partial_response) { … }

// static
bool ComposeUntrustedDialogStubDispatch::Accept(
    ComposeUntrustedDialog* impl,
    mojo::Message* message) { … }

// static
bool ComposeUntrustedDialogStubDispatch::AcceptWithResponder(
    ComposeUntrustedDialog* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kComposeUntrustedDialogValidationInfo[] = …;

bool ComposeUntrustedDialogRequestValidator::Accept(mojo::Message* message) { … }



}  // compose::mojom


namespace mojo {


// static
bool StructTraits<::compose::mojom::ComposeResponse::DataView, ::compose::mojom::ComposeResponsePtr>::Read(
    ::compose::mojom::ComposeResponse::DataView input,
    ::compose::mojom::ComposeResponsePtr* output) { … }


// static
bool StructTraits<::compose::mojom::PartialComposeResponse::DataView, ::compose::mojom::PartialComposeResponsePtr>::Read(
    ::compose::mojom::PartialComposeResponse::DataView input,
    ::compose::mojom::PartialComposeResponsePtr* output) { … }


// static
bool StructTraits<::compose::mojom::ComposeState::DataView, ::compose::mojom::ComposeStatePtr>::Read(
    ::compose::mojom::ComposeState::DataView input,
    ::compose::mojom::ComposeStatePtr* output) { … }


// static
bool StructTraits<::compose::mojom::ConfigurableParams::DataView, ::compose::mojom::ConfigurableParamsPtr>::Read(
    ::compose::mojom::ConfigurableParams::DataView input,
    ::compose::mojom::ConfigurableParamsPtr* output) { … }


// static
bool StructTraits<::compose::mojom::OpenMetadata::DataView, ::compose::mojom::OpenMetadataPtr>::Read(
    ::compose::mojom::OpenMetadata::DataView input,
    ::compose::mojom::OpenMetadataPtr* output) { … }

}  // namespace mojo


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


namespace compose::mojom {


void ComposeSessionUntrustedPageHandlerFactoryInterceptorForTesting::CreateComposeSessionUntrustedPageHandler(::mojo::PendingReceiver<ComposeClientUntrustedPageHandler> client_handler, ::mojo::PendingReceiver<ComposeSessionUntrustedPageHandler> handler, ::mojo::PendingRemote<ComposeUntrustedDialog> dialog) { … }
ComposeSessionUntrustedPageHandlerFactoryAsyncWaiter::ComposeSessionUntrustedPageHandlerFactoryAsyncWaiter(
    ComposeSessionUntrustedPageHandlerFactory* proxy) : … { … }

ComposeSessionUntrustedPageHandlerFactoryAsyncWaiter::~ComposeSessionUntrustedPageHandlerFactoryAsyncWaiter() = default;




void ComposeSessionUntrustedPageHandlerInterceptorForTesting::LogCancelEdit() { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::Compose(const std::string& input, bool edited) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::Rewrite(StyleModifier style) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::LogEditInput() { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::SaveWebUIState(const std::string& webui_state) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::AcceptComposeResult(AcceptComposeResultCallback callback) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::RequestInitialState(RequestInitialStateCallback callback) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::Undo(UndoCallback callback) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::RecoverFromErrorState(RecoverFromErrorStateCallback callback) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::Redo(RedoCallback callback) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::OpenBugReportingLink() { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::OpenComposeLearnMorePage() { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::OpenFeedbackSurveyLink() { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::OpenSignInPage() { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::SetUserFeedback(UserFeedback feedback) { … }
void ComposeSessionUntrustedPageHandlerInterceptorForTesting::EditResult(const std::string& new_result, EditResultCallback callback) { … }
ComposeSessionUntrustedPageHandlerAsyncWaiter::ComposeSessionUntrustedPageHandlerAsyncWaiter(
    ComposeSessionUntrustedPageHandler* proxy) : … { … }

ComposeSessionUntrustedPageHandlerAsyncWaiter::~ComposeSessionUntrustedPageHandlerAsyncWaiter() = default;

void ComposeSessionUntrustedPageHandlerAsyncWaiter::AcceptComposeResult(
    bool* out_success) { … }

bool ComposeSessionUntrustedPageHandlerAsyncWaiter::AcceptComposeResult(
    ) { … }

void ComposeSessionUntrustedPageHandlerAsyncWaiter::RequestInitialState(
    OpenMetadataPtr* out_initial_state) { … }

OpenMetadataPtr ComposeSessionUntrustedPageHandlerAsyncWaiter::RequestInitialState(
    ) { … }

void ComposeSessionUntrustedPageHandlerAsyncWaiter::Undo(
    ComposeStatePtr* out_last_state) { … }

ComposeStatePtr ComposeSessionUntrustedPageHandlerAsyncWaiter::Undo(
    ) { … }

void ComposeSessionUntrustedPageHandlerAsyncWaiter::RecoverFromErrorState(
    ComposeStatePtr* out_state_before_error) { … }

ComposeStatePtr ComposeSessionUntrustedPageHandlerAsyncWaiter::RecoverFromErrorState(
    ) { … }

void ComposeSessionUntrustedPageHandlerAsyncWaiter::Redo(
    ComposeStatePtr* out_next_state) { … }

ComposeStatePtr ComposeSessionUntrustedPageHandlerAsyncWaiter::Redo(
    ) { … }

void ComposeSessionUntrustedPageHandlerAsyncWaiter::EditResult(
    const std::string& new_result, bool* out_is_edited) { … }

bool ComposeSessionUntrustedPageHandlerAsyncWaiter::EditResult(
    const std::string& new_result) { … }




void ComposeClientUntrustedPageHandlerInterceptorForTesting::ShowUI() { … }
void ComposeClientUntrustedPageHandlerInterceptorForTesting::CloseUI(CloseReason reason) { … }
void ComposeClientUntrustedPageHandlerInterceptorForTesting::CompleteFirstRun() { … }
void ComposeClientUntrustedPageHandlerInterceptorForTesting::OpenComposeSettings() { … }
ComposeClientUntrustedPageHandlerAsyncWaiter::ComposeClientUntrustedPageHandlerAsyncWaiter(
    ComposeClientUntrustedPageHandler* proxy) : … { … }

ComposeClientUntrustedPageHandlerAsyncWaiter::~ComposeClientUntrustedPageHandlerAsyncWaiter() = default;




void ComposeUntrustedDialogInterceptorForTesting::ResponseReceived(ComposeResponsePtr response) { … }
void ComposeUntrustedDialogInterceptorForTesting::PartialResponseReceived(PartialComposeResponsePtr partial_response) { … }
ComposeUntrustedDialogAsyncWaiter::ComposeUntrustedDialogAsyncWaiter(
    ComposeUntrustedDialog* proxy) : … { … }

ComposeUntrustedDialogAsyncWaiter::~ComposeUntrustedDialogAsyncWaiter() = default;






}  // compose::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/chrome/common/compose/compose.mojom.cc
