ai_manager.mojom.cc | Explore in Territory

// third_party/blink/public/mojom/ai/ai_manager.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 "third_party/blink/public/mojom/ai/ai_manager.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 "third_party/blink/public/mojom/ai/ai_manager.mojom-params-data.h"
#include "third_party/blink/public/mojom/ai/ai_manager.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/ai/ai_manager.mojom-import-headers.h"
#include "third_party/blink/public/mojom/ai/ai_manager.mojom-test-utils.h"


namespace blink::mojom {
const char AIManagerCreateWriterClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t AIManagerCreateWriterClient::OnResult_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void AIManagerCreateWriterClientProxy::OnResult(
    ::mojo::PendingRemote<::blink::mojom::AIWriter> in_writer) { … }

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

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

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

const char AIManagerCreateRewriterClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t AIManagerCreateRewriterClient::OnResult_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void AIManagerCreateRewriterClientProxy::OnResult(
    ::mojo::PendingRemote<::blink::mojom::AIRewriter> in_rewriter) { … }

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

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

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

const char AIManagerCreateSummarizerClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t AIManagerCreateSummarizerClient::OnResult_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void AIManagerCreateSummarizerClientProxy::OnResult(
    ::mojo::PendingRemote<::blink::mojom::AISummarizer> in_summarizer) { … }

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

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

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

const char AIManager::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t AIManager::CanCreateTextSession_Sym::IPCStableHash() { … }
uint32_t AIManager::CreateTextSession_Sym::IPCStableHash() { … }
uint32_t AIManager::CanCreateSummarizer_Sym::IPCStableHash() { … }
uint32_t AIManager::CreateSummarizer_Sym::IPCStableHash() { … }
uint32_t AIManager::GetTextModelInfo_Sym::IPCStableHash() { … }
uint32_t AIManager::CreateWriter_Sym::IPCStableHash() { … }
uint32_t AIManager::CreateRewriter_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

void AIManagerProxy::CanCreateTextSession(
    CanCreateTextSessionCallback callback) { … }

void AIManagerProxy::CreateTextSession(
    ::mojo::PendingReceiver<::blink::mojom::AITextSession> in_session, ::blink::mojom::AITextSessionSamplingParamsPtr in_sampling_params, const std::optional<std::string>& in_system_prompt, CreateTextSessionCallback callback) { … }

void AIManagerProxy::CanCreateSummarizer(
    CanCreateSummarizerCallback callback) { … }

void AIManagerProxy::CreateSummarizer(
    ::mojo::PendingRemote<AIManagerCreateSummarizerClient> in_client, ::blink::mojom::AISummarizerOptionsPtr in_options, const std::optional<std::string>& in_shared_context) { … }

void AIManagerProxy::GetTextModelInfo(
    GetTextModelInfoCallback callback) { … }

void AIManagerProxy::CreateWriter(
    const std::optional<std::string>& in_shared_context, ::mojo::PendingRemote<AIManagerCreateWriterClient> in_client) { … }

void AIManagerProxy::CreateRewriter(
    const std::optional<std::string>& in_shared_context, ::blink::mojom::AIRewriterTone in_tone, ::blink::mojom::AIRewriterLength in_length, ::mojo::PendingRemote<AIManagerCreateRewriterClient> in_client) { … }
class AIManager_CanCreateTextSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void AIManager_CanCreateTextSession_ProxyToResponder::Run(
    ModelAvailabilityCheckResult in_result) { … }
class AIManager_CreateTextSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void AIManager_CreateTextSession_ProxyToResponder::Run(
    ::blink::mojom::AITextSessionInfoPtr in_info) { … }
class AIManager_CanCreateSummarizer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void AIManager_CanCreateSummarizer_ProxyToResponder::Run(
    ModelAvailabilityCheckResult in_result) { … }
class AIManager_GetTextModelInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void AIManager_GetTextModelInfo_ProxyToResponder::Run(
    ::blink::mojom::AITextModelInfoPtr in_text_model_info) { … }

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

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

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

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


}  // blink::mojom


namespace mojo {

}  // namespace mojo


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


namespace blink::mojom {


void AIManagerCreateWriterClientInterceptorForTesting::OnResult(::mojo::PendingRemote<::blink::mojom::AIWriter> writer) { … }
AIManagerCreateWriterClientAsyncWaiter::AIManagerCreateWriterClientAsyncWaiter(
    AIManagerCreateWriterClient* proxy) : … { … }

AIManagerCreateWriterClientAsyncWaiter::~AIManagerCreateWriterClientAsyncWaiter() = default;




void AIManagerCreateRewriterClientInterceptorForTesting::OnResult(::mojo::PendingRemote<::blink::mojom::AIRewriter> rewriter) { … }
AIManagerCreateRewriterClientAsyncWaiter::AIManagerCreateRewriterClientAsyncWaiter(
    AIManagerCreateRewriterClient* proxy) : … { … }

AIManagerCreateRewriterClientAsyncWaiter::~AIManagerCreateRewriterClientAsyncWaiter() = default;




void AIManagerCreateSummarizerClientInterceptorForTesting::OnResult(::mojo::PendingRemote<::blink::mojom::AISummarizer> summarizer) { … }
AIManagerCreateSummarizerClientAsyncWaiter::AIManagerCreateSummarizerClientAsyncWaiter(
    AIManagerCreateSummarizerClient* proxy) : … { … }

AIManagerCreateSummarizerClientAsyncWaiter::~AIManagerCreateSummarizerClientAsyncWaiter() = default;




void AIManagerInterceptorForTesting::CanCreateTextSession(CanCreateTextSessionCallback callback) { … }
void AIManagerInterceptorForTesting::CreateTextSession(::mojo::PendingReceiver<::blink::mojom::AITextSession> session, ::blink::mojom::AITextSessionSamplingParamsPtr sampling_params, const std::optional<std::string>& system_prompt, CreateTextSessionCallback callback) { … }
void AIManagerInterceptorForTesting::CanCreateSummarizer(CanCreateSummarizerCallback callback) { … }
void AIManagerInterceptorForTesting::CreateSummarizer(::mojo::PendingRemote<AIManagerCreateSummarizerClient> client, ::blink::mojom::AISummarizerOptionsPtr options, const std::optional<std::string>& shared_context) { … }
void AIManagerInterceptorForTesting::GetTextModelInfo(GetTextModelInfoCallback callback) { … }
void AIManagerInterceptorForTesting::CreateWriter(const std::optional<std::string>& shared_context, ::mojo::PendingRemote<AIManagerCreateWriterClient> client) { … }
void AIManagerInterceptorForTesting::CreateRewriter(const std::optional<std::string>& shared_context, ::blink::mojom::AIRewriterTone tone, ::blink::mojom::AIRewriterLength length, ::mojo::PendingRemote<AIManagerCreateRewriterClient> client) { … }
AIManagerAsyncWaiter::AIManagerAsyncWaiter(
    AIManager* proxy) : … { … }

AIManagerAsyncWaiter::~AIManagerAsyncWaiter() = default;

void AIManagerAsyncWaiter::CanCreateTextSession(
    ModelAvailabilityCheckResult* out_result) { … }

ModelAvailabilityCheckResult AIManagerAsyncWaiter::CanCreateTextSession(
    ) { … }

void AIManagerAsyncWaiter::CreateTextSession(
    ::mojo::PendingReceiver<::blink::mojom::AITextSession> session, ::blink::mojom::AITextSessionSamplingParamsPtr sampling_params, const std::optional<std::string>& system_prompt, ::blink::mojom::AITextSessionInfoPtr* out_info) { … }

::blink::mojom::AITextSessionInfoPtr AIManagerAsyncWaiter::CreateTextSession(
    ::mojo::PendingReceiver<::blink::mojom::AITextSession> session, ::blink::mojom::AITextSessionSamplingParamsPtr sampling_params, const std::optional<std::string>& system_prompt) { … }

void AIManagerAsyncWaiter::CanCreateSummarizer(
    ModelAvailabilityCheckResult* out_result) { … }

ModelAvailabilityCheckResult AIManagerAsyncWaiter::CanCreateSummarizer(
    ) { … }

void AIManagerAsyncWaiter::GetTextModelInfo(
    ::blink::mojom::AITextModelInfoPtr* out_text_model_info) { … }

::blink::mojom::AITextModelInfoPtr AIManagerAsyncWaiter::GetTextModelInfo(
    ) { … }






}  // blink::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/third_party/blink/public/mojom/ai/ai_manager.mojom.cc
