network_service.mojom.cc | Explore in Territory

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

#include "services/network/public/mojom/network_service.mojom-import-headers.h"
#include "services/network/public/mojom/network_service.mojom-test-utils.h"
#include "components/content_settings/core/common/content_settings_param_traits.h"
#include "net/cert/cert_verify_result.h"


namespace network::mojom {
HttpAuthStaticParams::HttpAuthStaticParams()
    : … { … }

HttpAuthStaticParams::HttpAuthStaticParams(
    const std::string& gssapi_library_name_in)
    : … { … }

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

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

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

HttpAuthDynamicParams::HttpAuthDynamicParams(
    std::optional<std::vector<std::string>> allowed_schemes_in,
    std::vector<std::string> patterns_allowed_to_use_all_schemes_in,
    const std::string& server_allowlist_in,
    const std::string& delegate_allowlist_in,
    bool delegate_by_kdc_policy_in,
    bool negotiate_disable_cname_lookup_in,
    bool enable_negotiate_port_in,
    bool ntlm_v2_enabled_in,
    const std::string& android_negotiate_account_type_in,
    bool allow_gssapi_library_load_in,
    bool basic_over_http_enabled_in)
    : … { … }

HttpAuthDynamicParams::~HttpAuthDynamicParams() = default;

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

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

EnvironmentVariable::EnvironmentVariable(
    const std::string& name_in,
    const std::string& value_in)
    : … { … }

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

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

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

NetworkServiceParams::NetworkServiceParams(
    ::network::mojom::ConnectionType initial_connection_type_in,
    ::network::mojom::ConnectionSubtype initial_connection_subtype_in,
    ::network::mojom::InitialAddressMapPtr initial_address_map_in,
    std::vector<EnvironmentVariablePtr> environment_in,
    ::mojo::PendingRemote<::network::mojom::URLLoaderNetworkServiceObserver> default_observer_in,
    bool first_party_sets_enabled_in,
    ::mojo::PendingRemote<::network::mojom::SystemDnsResolver> system_dns_resolver_in,
    ::network::mojom::IpProtectionProxyBypassPolicy ip_protection_proxy_bypass_policy_in)
    : … { … }

NetworkServiceParams::~NetworkServiceParams() = default;

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

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

SCTAuditingConfiguration::SCTAuditingConfiguration(
    double sampling_rate_in,
    ::base::TimeDelta log_expected_ingestion_delay_in,
    ::base::TimeDelta log_max_ingestion_random_delay_in,
    const ::GURL& report_uri_in,
    const ::GURL& hashdance_lookup_uri_in,
    const ::net::MutableNetworkTrafficAnnotationTag& traffic_annotation_in,
    const ::net::MutableNetworkTrafficAnnotationTag& hashdance_traffic_annotation_in)
    : … { … }

SCTAuditingConfiguration::~SCTAuditingConfiguration() = default;

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t GssapiLibraryLoadObserver::OnBeforeGssapiLibraryLoad_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void GssapiLibraryLoadObserverProxy::OnBeforeGssapiLibraryLoad(
    ) { … }

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

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

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

const char NetworkService::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t NetworkService::SetParams_Sym::IPCStableHash() { … }
uint32_t NetworkService::StartNetLog_Sym::IPCStableHash() { … }
uint32_t NetworkService::AttachNetLogProxy_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetSSLKeyLogFile_Sym::IPCStableHash() { … }
uint32_t NetworkService::CreateNetworkContext_Sym::IPCStableHash() { … }
uint32_t NetworkService::ConfigureStubHostResolver_Sym::IPCStableHash() { … }
uint32_t NetworkService::DisableQuic_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetUpHttpAuth_Sym::IPCStableHash() { … }
uint32_t NetworkService::ConfigureHttpAuthPrefs_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetRawHeadersAccess_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetMaxConnectionsPerProxyChain_Sym::IPCStableHash() { … }
uint32_t NetworkService::GetNetworkChangeManager_Sym::IPCStableHash() { … }
uint32_t NetworkService::GetNetworkQualityEstimatorManager_Sym::IPCStableHash() { … }
uint32_t NetworkService::GetDnsConfigChangeManager_Sym::IPCStableHash() { … }
uint32_t NetworkService::GetNetworkList_Sym::IPCStableHash() { … }
uint32_t NetworkService::OnTrustStoreChanged_Sym::IPCStableHash() { … }
uint32_t NetworkService::OnClientCertStoreChanged_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetEncryptionKey_Sym::IPCStableHash() { … }
uint32_t NetworkService::OnMemoryPressure_Sym::IPCStableHash() { … }
uint32_t NetworkService::OnPeerToPeerConnectionsCountChange_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetTrustTokenKeyCommitments_Sym::IPCStableHash() { … }
uint32_t NetworkService::ClearSCTAuditingCache_Sym::IPCStableHash() { … }
uint32_t NetworkService::ConfigureSCTAuditing_Sym::IPCStableHash() { … }
uint32_t NetworkService::UpdateCtLogList_Sym::IPCStableHash() { … }
uint32_t NetworkService::UpdateCtKnownPopularSCTs_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetCtEnforcementEnabled_Sym::IPCStableHash() { … }
uint32_t NetworkService::UpdateKeyPinsList_Sym::IPCStableHash() { … }
uint32_t NetworkService::BindTestInterfaceForTesting_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetFirstPartySets_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetExplicitlyAllowedPorts_Sym::IPCStableHash() { … }
uint32_t NetworkService::UpdateMaskedDomainList_Sym::IPCStableHash() { … }
uint32_t NetworkService::ParseHeaders_Sym::IPCStableHash() { … }
uint32_t NetworkService::EnableDataUseUpdates_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetIPv6ReachabilityOverride_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetGssapiLibraryLoadObserver_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetNetworkAnnotationMonitor_Sym::IPCStableHash() { … }
uint32_t NetworkService::SetTpcdMetadataGrants_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

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

void NetworkServiceProxy::SetParams(
    NetworkServiceParamsPtr in_params) { … }

void NetworkServiceProxy::StartNetLog(
    ::base::File in_file, uint64_t in_max_total_size, ::net::NetLogCaptureMode in_capture_mode, ::base::Value::Dict in_constants) { … }

void NetworkServiceProxy::AttachNetLogProxy(
    ::mojo::PendingRemote<::network::mojom::NetLogProxySource> in_proxy_source, ::mojo::PendingReceiver<::network::mojom::NetLogProxySink> in_proxy_sink) { … }

void NetworkServiceProxy::SetSSLKeyLogFile(
    ::base::File in_file) { … }

void NetworkServiceProxy::CreateNetworkContext(
    ::mojo::PendingReceiver<::network::mojom::NetworkContext> in_context, ::network::mojom::NetworkContextParamsPtr in_params) { … }

void NetworkServiceProxy::ConfigureStubHostResolver(
    bool in_insecure_dns_client_enabled, ::net::SecureDnsMode in_secure_dns_mode, const ::net::DnsOverHttpsConfig& in_dns_over_https_config, bool in_additional_dns_types_enabled) { … }

void NetworkServiceProxy::DisableQuic(
    ) { … }

void NetworkServiceProxy::SetUpHttpAuth(
    HttpAuthStaticParamsPtr in_http_auth_static_params) { … }

void NetworkServiceProxy::ConfigureHttpAuthPrefs(
    HttpAuthDynamicParamsPtr in_http_auth_dynamic_params) { … }

void NetworkServiceProxy::SetRawHeadersAccess(
    int32_t in_process_id, const std::vector<::url::Origin>& in_origins) { … }

void NetworkServiceProxy::SetMaxConnectionsPerProxyChain(
    int32_t in_max_connections) { … }

void NetworkServiceProxy::GetNetworkChangeManager(
    ::mojo::PendingReceiver<::network::mojom::NetworkChangeManager> in_network_change_manager) { … }

void NetworkServiceProxy::GetNetworkQualityEstimatorManager(
    ::mojo::PendingReceiver<::network::mojom::NetworkQualityEstimatorManager> in_receiver) { … }

void NetworkServiceProxy::GetDnsConfigChangeManager(
    ::mojo::PendingReceiver<::network::mojom::DnsConfigChangeManager> in_receiver) { … }

void NetworkServiceProxy::GetNetworkList(
    uint32_t in_policy, GetNetworkListCallback callback) { … }

void NetworkServiceProxy::OnTrustStoreChanged(
    ) { … }

void NetworkServiceProxy::OnClientCertStoreChanged(
    ) { … }

void NetworkServiceProxy::SetEncryptionKey(
    const std::string& in_encryption_key) { … }

void NetworkServiceProxy::OnMemoryPressure(
    ::base::MemoryPressureListener::MemoryPressureLevel in_memory_pressure_level) { … }

void NetworkServiceProxy::OnPeerToPeerConnectionsCountChange(
    uint32_t in_count) { … }

void NetworkServiceProxy::SetTrustTokenKeyCommitments(
    const std::string& in_raw_commitments, SetTrustTokenKeyCommitmentsCallback callback) { … }

void NetworkServiceProxy::ClearSCTAuditingCache(
    ) { … }

void NetworkServiceProxy::ConfigureSCTAuditing(
    SCTAuditingConfigurationPtr in_configuration) { … }

void NetworkServiceProxy::UpdateCtLogList(
    std::vector<::network::mojom::CTLogInfoPtr> in_log_list, UpdateCtLogListCallback callback) { … }

void NetworkServiceProxy::UpdateCtKnownPopularSCTs(
    const std::vector<std::vector<uint8_t>>& in_sct_hashes, UpdateCtKnownPopularSCTsCallback callback) { … }

void NetworkServiceProxy::SetCtEnforcementEnabled(
    bool in_enabled, SetCtEnforcementEnabledCallback callback) { … }

void NetworkServiceProxy::UpdateKeyPinsList(
    ::network::mojom::PinListPtr in_pin_list, ::base::Time in_update_time) { … }

void NetworkServiceProxy::BindTestInterfaceForTesting(
    ::mojo::PendingReceiver<::network::mojom::NetworkServiceTest> in_receiver) { … }

void NetworkServiceProxy::SetFirstPartySets(
    ::net::GlobalFirstPartySets in_sets) { … }

void NetworkServiceProxy::SetExplicitlyAllowedPorts(
    const std::vector<uint16_t>& in_ports) { … }

void NetworkServiceProxy::UpdateMaskedDomainList(
    ::mojo_base::ProtoWrapper in_masked_domain_list, const std::vector<std::string>& in_exclusion_list) { … }

void NetworkServiceProxy::ParseHeaders(
    const ::GURL& in_url, const ::scoped_refptr<::net::HttpResponseHeaders>& in_headers, ParseHeadersCallback callback) { … }

void NetworkServiceProxy::EnableDataUseUpdates(
    bool in_enable) { … }

void NetworkServiceProxy::SetIPv6ReachabilityOverride(
    bool in_reachability_override) { … }

void NetworkServiceProxy::SetGssapiLibraryLoadObserver(
    ::mojo::PendingRemote<GssapiLibraryLoadObserver> in_gssapi_library_load_observer) { … }

void NetworkServiceProxy::SetNetworkAnnotationMonitor(
    ::mojo::PendingRemote<::network::mojom::NetworkAnnotationMonitor> in_remote) { … }

void NetworkServiceProxy::SetTpcdMetadataGrants(
    const std::vector<::ContentSettingPatternSource>& in_settings) { … }
class NetworkService_GetNetworkList_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkService_GetNetworkList_ProxyToResponder::Run(
    const std::optional<std::vector<::net::NetworkInterface>>& in_networks) { … }
class NetworkService_SetTrustTokenKeyCommitments_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkService_SetTrustTokenKeyCommitments_ProxyToResponder::Run(
    ) { … }
class NetworkService_UpdateCtLogList_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkService_UpdateCtLogList_ProxyToResponder::Run(
    ) { … }
class NetworkService_UpdateCtKnownPopularSCTs_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkService_UpdateCtKnownPopularSCTs_ProxyToResponder::Run(
    ) { … }
class NetworkService_SetCtEnforcementEnabled_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkService_SetCtEnforcementEnabled_ProxyToResponder::Run(
    ) { … }
class NetworkService_ParseHeaders_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkService_ParseHeaders_ProxyToResponder::Run(
    ::network::mojom::ParsedHeadersPtr in_parsed_headers) { … }

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

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

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

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


}  // network::mojom


namespace mojo {


// static
bool StructTraits<::network::mojom::HttpAuthStaticParams::DataView, ::network::mojom::HttpAuthStaticParamsPtr>::Read(
    ::network::mojom::HttpAuthStaticParams::DataView input,
    ::network::mojom::HttpAuthStaticParamsPtr* output) { … }


// static
bool StructTraits<::network::mojom::HttpAuthDynamicParams::DataView, ::network::mojom::HttpAuthDynamicParamsPtr>::Read(
    ::network::mojom::HttpAuthDynamicParams::DataView input,
    ::network::mojom::HttpAuthDynamicParamsPtr* output) { … }


// static
bool StructTraits<::network::mojom::EnvironmentVariable::DataView, ::network::mojom::EnvironmentVariablePtr>::Read(
    ::network::mojom::EnvironmentVariable::DataView input,
    ::network::mojom::EnvironmentVariablePtr* output) { … }


// static
bool StructTraits<::network::mojom::NetworkServiceParams::DataView, ::network::mojom::NetworkServiceParamsPtr>::Read(
    ::network::mojom::NetworkServiceParams::DataView input,
    ::network::mojom::NetworkServiceParamsPtr* output) { … }


// static
bool StructTraits<::network::mojom::SCTAuditingConfiguration::DataView, ::network::mojom::SCTAuditingConfigurationPtr>::Read(
    ::network::mojom::SCTAuditingConfiguration::DataView input,
    ::network::mojom::SCTAuditingConfigurationPtr* 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 network::mojom {


void GssapiLibraryLoadObserverInterceptorForTesting::OnBeforeGssapiLibraryLoad() { … }
GssapiLibraryLoadObserverAsyncWaiter::GssapiLibraryLoadObserverAsyncWaiter(
    GssapiLibraryLoadObserver* proxy) : … { … }

GssapiLibraryLoadObserverAsyncWaiter::~GssapiLibraryLoadObserverAsyncWaiter() = default;




void NetworkServiceInterceptorForTesting::SetParams(NetworkServiceParamsPtr params) { … }
void NetworkServiceInterceptorForTesting::StartNetLog(::base::File file, uint64_t max_total_size, ::net::NetLogCaptureMode capture_mode, ::base::Value::Dict constants) { … }
void NetworkServiceInterceptorForTesting::AttachNetLogProxy(::mojo::PendingRemote<::network::mojom::NetLogProxySource> proxy_source, ::mojo::PendingReceiver<::network::mojom::NetLogProxySink> proxy_sink) { … }
void NetworkServiceInterceptorForTesting::SetSSLKeyLogFile(::base::File file) { … }
void NetworkServiceInterceptorForTesting::CreateNetworkContext(::mojo::PendingReceiver<::network::mojom::NetworkContext> context, ::network::mojom::NetworkContextParamsPtr params) { … }
void NetworkServiceInterceptorForTesting::ConfigureStubHostResolver(bool insecure_dns_client_enabled, ::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& dns_over_https_config, bool additional_dns_types_enabled) { … }
void NetworkServiceInterceptorForTesting::DisableQuic() { … }
void NetworkServiceInterceptorForTesting::SetUpHttpAuth(HttpAuthStaticParamsPtr http_auth_static_params) { … }
void NetworkServiceInterceptorForTesting::ConfigureHttpAuthPrefs(HttpAuthDynamicParamsPtr http_auth_dynamic_params) { … }
void NetworkServiceInterceptorForTesting::SetRawHeadersAccess(int32_t process_id, const std::vector<::url::Origin>& origins) { … }
void NetworkServiceInterceptorForTesting::SetMaxConnectionsPerProxyChain(int32_t max_connections) { … }
void NetworkServiceInterceptorForTesting::GetNetworkChangeManager(::mojo::PendingReceiver<::network::mojom::NetworkChangeManager> network_change_manager) { … }
void NetworkServiceInterceptorForTesting::GetNetworkQualityEstimatorManager(::mojo::PendingReceiver<::network::mojom::NetworkQualityEstimatorManager> receiver) { … }
void NetworkServiceInterceptorForTesting::GetDnsConfigChangeManager(::mojo::PendingReceiver<::network::mojom::DnsConfigChangeManager> receiver) { … }
void NetworkServiceInterceptorForTesting::GetNetworkList(uint32_t policy, GetNetworkListCallback callback) { … }
void NetworkServiceInterceptorForTesting::OnTrustStoreChanged() { … }
void NetworkServiceInterceptorForTesting::OnClientCertStoreChanged() { … }
void NetworkServiceInterceptorForTesting::SetEncryptionKey(const std::string& encryption_key) { … }
void NetworkServiceInterceptorForTesting::OnMemoryPressure(::base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) { … }
void NetworkServiceInterceptorForTesting::OnPeerToPeerConnectionsCountChange(uint32_t count) { … }
void NetworkServiceInterceptorForTesting::SetTrustTokenKeyCommitments(const std::string& raw_commitments, SetTrustTokenKeyCommitmentsCallback callback) { … }
void NetworkServiceInterceptorForTesting::ClearSCTAuditingCache() { … }
void NetworkServiceInterceptorForTesting::ConfigureSCTAuditing(SCTAuditingConfigurationPtr configuration) { … }
void NetworkServiceInterceptorForTesting::UpdateCtLogList(std::vector<::network::mojom::CTLogInfoPtr> log_list, UpdateCtLogListCallback callback) { … }
void NetworkServiceInterceptorForTesting::UpdateCtKnownPopularSCTs(const std::vector<std::vector<uint8_t>>& sct_hashes, UpdateCtKnownPopularSCTsCallback callback) { … }
void NetworkServiceInterceptorForTesting::SetCtEnforcementEnabled(bool enabled, SetCtEnforcementEnabledCallback callback) { … }
void NetworkServiceInterceptorForTesting::UpdateKeyPinsList(::network::mojom::PinListPtr pin_list, ::base::Time update_time) { … }
void NetworkServiceInterceptorForTesting::BindTestInterfaceForTesting(::mojo::PendingReceiver<::network::mojom::NetworkServiceTest> receiver) { … }
void NetworkServiceInterceptorForTesting::SetFirstPartySets(::net::GlobalFirstPartySets sets) { … }
void NetworkServiceInterceptorForTesting::SetExplicitlyAllowedPorts(const std::vector<uint16_t>& ports) { … }
void NetworkServiceInterceptorForTesting::UpdateMaskedDomainList(::mojo_base::ProtoWrapper masked_domain_list, const std::vector<std::string>& exclusion_list) { … }
void NetworkServiceInterceptorForTesting::ParseHeaders(const ::GURL& url, const ::scoped_refptr<::net::HttpResponseHeaders>& headers, ParseHeadersCallback callback) { … }
void NetworkServiceInterceptorForTesting::EnableDataUseUpdates(bool enable) { … }
void NetworkServiceInterceptorForTesting::SetIPv6ReachabilityOverride(bool reachability_override) { … }
void NetworkServiceInterceptorForTesting::SetGssapiLibraryLoadObserver(::mojo::PendingRemote<GssapiLibraryLoadObserver> gssapi_library_load_observer) { … }
void NetworkServiceInterceptorForTesting::SetNetworkAnnotationMonitor(::mojo::PendingRemote<::network::mojom::NetworkAnnotationMonitor> remote) { … }
void NetworkServiceInterceptorForTesting::SetTpcdMetadataGrants(const std::vector<::ContentSettingPatternSource>& settings) { … }
NetworkServiceAsyncWaiter::NetworkServiceAsyncWaiter(
    NetworkService* proxy) : … { … }

NetworkServiceAsyncWaiter::~NetworkServiceAsyncWaiter() = default;

void NetworkServiceAsyncWaiter::GetNetworkList(
    uint32_t policy, std::optional<std::vector<::net::NetworkInterface>>* out_networks) { … }

std::optional<std::vector<::net::NetworkInterface>> NetworkServiceAsyncWaiter::GetNetworkList(
    uint32_t policy) { … }

void NetworkServiceAsyncWaiter::SetTrustTokenKeyCommitments(
    const std::string& raw_commitments) { … }



void NetworkServiceAsyncWaiter::UpdateCtLogList(
    std::vector<::network::mojom::CTLogInfoPtr> log_list) { … }



void NetworkServiceAsyncWaiter::UpdateCtKnownPopularSCTs(
    const std::vector<std::vector<uint8_t>>& sct_hashes) { … }



void NetworkServiceAsyncWaiter::SetCtEnforcementEnabled(
    bool enabled) { … }



void NetworkServiceAsyncWaiter::ParseHeaders(
    const ::GURL& url, const ::scoped_refptr<::net::HttpResponseHeaders>& headers, ::network::mojom::ParsedHeadersPtr* out_parsed_headers) { … }

::network::mojom::ParsedHeadersPtr NetworkServiceAsyncWaiter::ParseHeaders(
    const ::GURL& url, const ::scoped_refptr<::net::HttpResponseHeaders>& headers) { … }






}  // network::mojom


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