on_device_model.mojom.cc | Explore in Territory

// services/on_device_model/public/mojom/on_device_model.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 "services/on_device_model/public/mojom/on_device_model.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 "services/on_device_model/public/mojom/on_device_model.mojom-params-data.h"
#include "services/on_device_model/public/mojom/on_device_model.mojom-shared-message-ids.h"

#include "services/on_device_model/public/mojom/on_device_model.mojom-import-headers.h"
#include "services/on_device_model/public/mojom/on_device_model.mojom-test-utils.h"


namespace on_device_model::mojom {
AdaptationAssets::AdaptationAssets()
    : … { … }

AdaptationAssets::AdaptationAssets(
    ::base::File weights_in)
    : … { … }

AdaptationAssets::AdaptationAssets(
    ::base::File weights_in,
    const std::optional<::base::FilePath>& weights_path_in)
    : … { … }

AdaptationAssets::~AdaptationAssets() = default;

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

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

LanguageDetectionResult::LanguageDetectionResult(
    const std::string& code_in,
    float reliability_in)
    : … { … }

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

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

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

SafetyInfo::SafetyInfo(
    std::vector<float> class_scores_in,
    LanguageDetectionResultPtr language_in)
    : … { … }

SafetyInfo::~SafetyInfo() = default;

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

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

ResponseChunk::ResponseChunk(
    const std::string& text_in,
    SafetyInfoPtr safety_info_in)
    : … { … }

ResponseChunk::~ResponseChunk() = default;

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

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

ResponseSummary::ResponseSummary(
    SafetyInfoPtr safety_info_in)
    : … { … }

ResponseSummary::~ResponseSummary() = default;

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

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

LoadAdaptationParams::LoadAdaptationParams(
    ::on_device_model::AdaptationAssets assets_in)
    : … { … }

LoadAdaptationParams::~LoadAdaptationParams() = default;

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

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

InputOptions::InputOptions(
    const std::string& text_in,
    std::optional<uint32_t> max_tokens_in,
    std::optional<uint32_t> token_offset_in,
    bool ignore_context_in,
    std::optional<uint32_t> max_output_tokens_in,
    std::optional<uint32_t> unused_safety_interval_in,
    std::optional<uint32_t> top_k_in,
    std::optional<float> temperature_in)
    : … { … }

InputOptions::~InputOptions() = default;

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t StreamingResponder::OnResponse_Sym::IPCStableHash() { … }
uint32_t StreamingResponder::OnComplete_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void StreamingResponderProxy::OnResponse(
    ResponseChunkPtr in_chunk) { … }

void StreamingResponderProxy::OnComplete(
    ResponseSummaryPtr in_summary) { … }

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

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

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

const char ContextClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ContextClient::OnComplete_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void ContextClientProxy::OnComplete(
    uint32_t in_tokens_processed) { … }

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

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

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

const char Session::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t Session::AddContext_Sym::IPCStableHash() { … }
uint32_t Session::Execute_Sym::IPCStableHash() { … }
uint32_t Session::GetSizeInTokens_Sym::IPCStableHash() { … }
uint32_t Session::Score_Sym::IPCStableHash() { … }
uint32_t Session::Clone_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

void SessionProxy::AddContext(
    InputOptionsPtr in_input, ::mojo::PendingRemote<ContextClient> in_client) { … }

void SessionProxy::Execute(
    InputOptionsPtr in_input, ::mojo::PendingRemote<StreamingResponder> in_response) { … }

void SessionProxy::GetSizeInTokens(
    const std::string& in_text, GetSizeInTokensCallback callback) { … }

void SessionProxy::Score(
    const std::string& in_text, ScoreCallback callback) { … }

void SessionProxy::Clone(
    ::mojo::PendingReceiver<Session> in_session) { … }
class Session_GetSizeInTokens_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Session_GetSizeInTokens_ProxyToResponder::Run(
    uint32_t in_size) { … }
class Session_Score_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Session_Score_ProxyToResponder::Run(
    float in_probability) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t OnDeviceModel::StartSession_Sym::IPCStableHash() { … }
uint32_t OnDeviceModel::ClassifyTextSafety_Sym::IPCStableHash() { … }
uint32_t OnDeviceModel::DetectLanguage_Sym::IPCStableHash() { … }
uint32_t OnDeviceModel::LoadAdaptation_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

void OnDeviceModelProxy::StartSession(
    ::mojo::PendingReceiver<Session> in_session) { … }

void OnDeviceModelProxy::ClassifyTextSafety(
    const std::string& in_text, ClassifyTextSafetyCallback callback) { … }

void OnDeviceModelProxy::DetectLanguage(
    const std::string& in_text, DetectLanguageCallback callback) { … }

void OnDeviceModelProxy::LoadAdaptation(
    LoadAdaptationParamsPtr in_params, ::mojo::PendingReceiver<OnDeviceModel> in_model, LoadAdaptationCallback callback) { … }
class OnDeviceModel_ClassifyTextSafety_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void OnDeviceModel_ClassifyTextSafety_ProxyToResponder::Run(
    SafetyInfoPtr in_safety_info) { … }
class OnDeviceModel_DetectLanguage_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void OnDeviceModel_DetectLanguage_ProxyToResponder::Run(
    LanguageDetectionResultPtr in_result) { … }
class OnDeviceModel_LoadAdaptation_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void OnDeviceModel_LoadAdaptation_ProxyToResponder::Run(
    LoadModelResult in_result) { … }

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

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

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

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


}  // on_device_model::mojom


namespace mojo {


// static
bool StructTraits<::on_device_model::mojom::AdaptationAssets::DataView, ::on_device_model::mojom::AdaptationAssetsPtr>::Read(
    ::on_device_model::mojom::AdaptationAssets::DataView input,
    ::on_device_model::mojom::AdaptationAssetsPtr* output) { … }


// static
bool StructTraits<::on_device_model::mojom::LanguageDetectionResult::DataView, ::on_device_model::mojom::LanguageDetectionResultPtr>::Read(
    ::on_device_model::mojom::LanguageDetectionResult::DataView input,
    ::on_device_model::mojom::LanguageDetectionResultPtr* output) { … }


// static
bool StructTraits<::on_device_model::mojom::SafetyInfo::DataView, ::on_device_model::mojom::SafetyInfoPtr>::Read(
    ::on_device_model::mojom::SafetyInfo::DataView input,
    ::on_device_model::mojom::SafetyInfoPtr* output) { … }


// static
bool StructTraits<::on_device_model::mojom::ResponseChunk::DataView, ::on_device_model::mojom::ResponseChunkPtr>::Read(
    ::on_device_model::mojom::ResponseChunk::DataView input,
    ::on_device_model::mojom::ResponseChunkPtr* output) { … }


// static
bool StructTraits<::on_device_model::mojom::ResponseSummary::DataView, ::on_device_model::mojom::ResponseSummaryPtr>::Read(
    ::on_device_model::mojom::ResponseSummary::DataView input,
    ::on_device_model::mojom::ResponseSummaryPtr* output) { … }


// static
bool StructTraits<::on_device_model::mojom::LoadAdaptationParams::DataView, ::on_device_model::mojom::LoadAdaptationParamsPtr>::Read(
    ::on_device_model::mojom::LoadAdaptationParams::DataView input,
    ::on_device_model::mojom::LoadAdaptationParamsPtr* output) { … }


// static
bool StructTraits<::on_device_model::mojom::InputOptions::DataView, ::on_device_model::mojom::InputOptionsPtr>::Read(
    ::on_device_model::mojom::InputOptions::DataView input,
    ::on_device_model::mojom::InputOptionsPtr* 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 on_device_model::mojom {


void StreamingResponderInterceptorForTesting::OnResponse(ResponseChunkPtr chunk) { … }
void StreamingResponderInterceptorForTesting::OnComplete(ResponseSummaryPtr summary) { … }
StreamingResponderAsyncWaiter::StreamingResponderAsyncWaiter(
    StreamingResponder* proxy) : … { … }

StreamingResponderAsyncWaiter::~StreamingResponderAsyncWaiter() = default;




void ContextClientInterceptorForTesting::OnComplete(uint32_t tokens_processed) { … }
ContextClientAsyncWaiter::ContextClientAsyncWaiter(
    ContextClient* proxy) : … { … }

ContextClientAsyncWaiter::~ContextClientAsyncWaiter() = default;




void SessionInterceptorForTesting::AddContext(InputOptionsPtr input, ::mojo::PendingRemote<ContextClient> client) { … }
void SessionInterceptorForTesting::Execute(InputOptionsPtr input, ::mojo::PendingRemote<StreamingResponder> response) { … }
void SessionInterceptorForTesting::GetSizeInTokens(const std::string& text, GetSizeInTokensCallback callback) { … }
void SessionInterceptorForTesting::Score(const std::string& text, ScoreCallback callback) { … }
void SessionInterceptorForTesting::Clone(::mojo::PendingReceiver<Session> session) { … }
SessionAsyncWaiter::SessionAsyncWaiter(
    Session* proxy) : … { … }

SessionAsyncWaiter::~SessionAsyncWaiter() = default;

void SessionAsyncWaiter::GetSizeInTokens(
    const std::string& text, uint32_t* out_size) { … }

uint32_t SessionAsyncWaiter::GetSizeInTokens(
    const std::string& text) { … }

void SessionAsyncWaiter::Score(
    const std::string& text, float* out_probability) { … }

float SessionAsyncWaiter::Score(
    const std::string& text) { … }




void OnDeviceModelInterceptorForTesting::StartSession(::mojo::PendingReceiver<Session> session) { … }
void OnDeviceModelInterceptorForTesting::ClassifyTextSafety(const std::string& text, ClassifyTextSafetyCallback callback) { … }
void OnDeviceModelInterceptorForTesting::DetectLanguage(const std::string& text, DetectLanguageCallback callback) { … }
void OnDeviceModelInterceptorForTesting::LoadAdaptation(LoadAdaptationParamsPtr params, ::mojo::PendingReceiver<OnDeviceModel> model, LoadAdaptationCallback callback) { … }
OnDeviceModelAsyncWaiter::OnDeviceModelAsyncWaiter(
    OnDeviceModel* proxy) : … { … }

OnDeviceModelAsyncWaiter::~OnDeviceModelAsyncWaiter() = default;

void OnDeviceModelAsyncWaiter::ClassifyTextSafety(
    const std::string& text, SafetyInfoPtr* out_safety_info) { … }

SafetyInfoPtr OnDeviceModelAsyncWaiter::ClassifyTextSafety(
    const std::string& text) { … }

void OnDeviceModelAsyncWaiter::DetectLanguage(
    const std::string& text, LanguageDetectionResultPtr* out_result) { … }

LanguageDetectionResultPtr OnDeviceModelAsyncWaiter::DetectLanguage(
    const std::string& text) { … }

void OnDeviceModelAsyncWaiter::LoadAdaptation(
    LoadAdaptationParamsPtr params, ::mojo::PendingReceiver<OnDeviceModel> model, LoadModelResult* out_result) { … }

LoadModelResult OnDeviceModelAsyncWaiter::LoadAdaptation(
    LoadAdaptationParamsPtr params, ::mojo::PendingReceiver<OnDeviceModel> model) { … }






}  // on_device_model::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/services/on_device_model/public/mojom/on_device_model.mojom.cc
