network_service_test.mojom.cc | Explore in Territory

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

#include "services/network/public/mojom/network_service_test.mojom-import-headers.h"
#include "services/network/public/mojom/network_service_test.mojom-test-utils.h"
#include "net/cert/cert_verify_result.h"


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

Rule::Rule(
    ResolverType resolver_type_in,
    const std::string& host_pattern_in,
    const std::string& replacement_in,
    int32_t host_resolver_flags_in,
    std::vector<std::string> dns_aliases_in)
    : … { … }

Rule::~Rule() = default;

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

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

SimpleCacheOpenEntryResult::SimpleCacheOpenEntryResult(
    int32_t error_in,
    const std::string& key_in,
    ::mojo::PendingRemote<SimpleCacheEntry> entry_in)
    : … { … }

SimpleCacheOpenEntryResult::~SimpleCacheOpenEntryResult() = default;

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SimpleCacheEntry::WriteData_Sym::IPCStableHash() { … }
uint32_t SimpleCacheEntry::ReadData_Sym::IPCStableHash() { … }
uint32_t SimpleCacheEntry::WriteSparseData_Sym::IPCStableHash() { … }
uint32_t SimpleCacheEntry::ReadSparseData_Sym::IPCStableHash() { … }
uint32_t SimpleCacheEntry::Close_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

void SimpleCacheEntryProxy::WriteData(
    int32_t in_index, int32_t in_offset, const std::vector<uint8_t>& in_data, bool in_truncate, WriteDataCallback callback) { … }

void SimpleCacheEntryProxy::ReadData(
    int32_t in_index, int32_t in_offset, uint32_t in_length, ReadDataCallback callback) { … }

void SimpleCacheEntryProxy::WriteSparseData(
    int32_t in_offset, const std::vector<uint8_t>& in_data, WriteSparseDataCallback callback) { … }

void SimpleCacheEntryProxy::ReadSparseData(
    int32_t in_offset, uint32_t in_length, ReadSparseDataCallback callback) { … }

void SimpleCacheEntryProxy::Close(
    CloseCallback callback) { … }
class SimpleCacheEntry_WriteData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCacheEntry_WriteData_ProxyToResponder::Run(
    int32_t in_result) { … }
class SimpleCacheEntry_ReadData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCacheEntry_ReadData_ProxyToResponder::Run(
    const std::vector<uint8_t>& in_data, int32_t in_result) { … }
class SimpleCacheEntry_WriteSparseData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCacheEntry_WriteSparseData_ProxyToResponder::Run(
    int32_t in_result) { … }
class SimpleCacheEntry_ReadSparseData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCacheEntry_ReadSparseData_ProxyToResponder::Run(
    const std::vector<uint8_t>& in_data, int32_t in_result) { … }
class SimpleCacheEntry_Close_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCacheEntry_Close_ProxyToResponder::Run(
    ) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SimpleCacheEntryEnumerator::GetNext_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void SimpleCacheEntryEnumeratorProxy::GetNext(
    GetNextCallback callback) { … }
class SimpleCacheEntryEnumerator_GetNext_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCacheEntryEnumerator_GetNext_ProxyToResponder::Run(
    SimpleCacheOpenEntryResultPtr in_result) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SimpleCache::CreateEntry_Sym::IPCStableHash() { … }
uint32_t SimpleCache::OpenEntry_Sym::IPCStableHash() { … }
uint32_t SimpleCache::DoomEntry_Sym::IPCStableHash() { … }
uint32_t SimpleCache::DoomAllEntries_Sym::IPCStableHash() { … }
uint32_t SimpleCache::EnumerateEntries_Sym::IPCStableHash() { … }
uint32_t SimpleCache::Detach_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

void SimpleCacheProxy::CreateEntry(
    const std::string& in_key, CreateEntryCallback callback) { … }

void SimpleCacheProxy::OpenEntry(
    const std::string& in_key, OpenEntryCallback callback) { … }

void SimpleCacheProxy::DoomEntry(
    const std::string& in_key, DoomEntryCallback callback) { … }

void SimpleCacheProxy::DoomAllEntries(
    DoomAllEntriesCallback callback) { … }

void SimpleCacheProxy::EnumerateEntries(
    ::mojo::PendingReceiver<SimpleCacheEntryEnumerator> in_receiver) { … }

void SimpleCacheProxy::Detach(
    DetachCallback callback) { … }
class SimpleCache_CreateEntry_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCache_CreateEntry_ProxyToResponder::Run(
    ::mojo::PendingRemote<SimpleCacheEntry> in_entry, int32_t in_error) { … }
class SimpleCache_OpenEntry_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCache_OpenEntry_ProxyToResponder::Run(
    ::mojo::PendingRemote<SimpleCacheEntry> in_entry, int32_t in_error) { … }
class SimpleCache_DoomEntry_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCache_DoomEntry_ProxyToResponder::Run(
    int32_t in_result) { … }
class SimpleCache_DoomAllEntries_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCache_DoomAllEntries_ProxyToResponder::Run(
    int32_t in_result) { … }
class SimpleCache_Detach_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void SimpleCache_Detach_ProxyToResponder::Run(
    ) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t NetworkServiceTest::AddRules_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SimulateNetworkChange_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SimulateNetworkQualityChange_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::ForceNetworkQualityEstimatorReportWifiAsSlow2G_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SimulateCrash_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::MockCertVerifierSetDefaultResult_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::MockCertVerifierAddResultForCertAndHost_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SetTransportSecurityStateSource_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SetAllowNetworkAccessToHostResolutions_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::ReplaceSystemDnsConfig_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SetTestDohConfig_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::CrashOnResolveHost_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::CrashOnGetCookieList_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::GetLatestMemoryPressureLevel_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::GetPeerToPeerConnectionsCountChange_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::GetEnvironmentVariableValue_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::Log_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::ActivateFieldTrial_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SetSCTAuditingRetryDelay_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::OpenFile_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::EnumerateFiles_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::CreateSimpleCache_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::MakeRequestToServer_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::ResolveOwnHostnameWithSystemDns_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::SetIPv6ProbeResult_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::GetAddressMapCacheLinux_Sym::IPCStableHash() { … }
uint32_t NetworkServiceTest::AllowsGSSAPILibraryLoad_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool NetworkServiceTest::AddRules(std::vector<RulePtr> rules) { … }
bool NetworkServiceTest::MockCertVerifierSetDefaultResult(int32_t default_result) { … }
bool NetworkServiceTest::MockCertVerifierAddResultForCertAndHost(const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv) { … }
bool NetworkServiceTest::SetTransportSecurityStateSource(uint16_t reporting_port) { … }
bool NetworkServiceTest::SetAllowNetworkAccessToHostResolutions() { … }
bool NetworkServiceTest::ReplaceSystemDnsConfig() { … }
bool NetworkServiceTest::SetTestDohConfig(::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config) { … }
bool NetworkServiceTest::GetLatestMemoryPressureLevel(::base::MemoryPressureListener::MemoryPressureLevel* out_memory_pressure_level) { … }
bool NetworkServiceTest::GetPeerToPeerConnectionsCountChange(uint32_t* out_connection_count) { … }
bool NetworkServiceTest::GetEnvironmentVariableValue(const std::string& name, std::string* out_value) { … }
bool NetworkServiceTest::Log(const std::string& message) { … }
bool NetworkServiceTest::SetSCTAuditingRetryDelay(std::optional<::base::TimeDelta> delay) { … }
bool NetworkServiceTest::GetAddressMapCacheLinux(::net::AddressMapOwnerLinux::AddressMap* out_addr_map, ::std::unordered_set<int>* out_links) { … }
bool NetworkServiceTest::AllowsGSSAPILibraryLoad(bool* out_allow_gssapi_library_load) { … }
class NetworkServiceTest_AddRules_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

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

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

class NetworkServiceTest_ForceNetworkQualityEstimatorReportWifiAsSlow2G_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_MockCertVerifierSetDefaultResult_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_MockCertVerifierSetDefaultResult_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_MockCertVerifierAddResultForCertAndHost_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_MockCertVerifierAddResultForCertAndHost_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_SetTransportSecurityStateSource_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_SetTransportSecurityStateSource_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_SetAllowNetworkAccessToHostResolutions_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_SetAllowNetworkAccessToHostResolutions_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_ReplaceSystemDnsConfig_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_ReplaceSystemDnsConfig_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_SetTestDohConfig_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_SetTestDohConfig_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_GetLatestMemoryPressureLevel_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_GetLatestMemoryPressureLevel_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_GetPeerToPeerConnectionsCountChange_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_GetPeerToPeerConnectionsCountChange_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_GetEnvironmentVariableValue_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_GetEnvironmentVariableValue_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_Log_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_Log_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_SetSCTAuditingRetryDelay_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

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

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

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

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

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

class NetworkServiceTest_SetIPv6ProbeResult_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_GetAddressMapCacheLinux_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class NetworkServiceTest_GetAddressMapCacheLinux_ForwardToCallback
    : public mojo::MessageReceiver { … };
class NetworkServiceTest_AllowsGSSAPILibraryLoad_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

NetworkServiceTestProxy::NetworkServiceTestProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }
bool NetworkServiceTestProxy::AddRules(
    std::vector<RulePtr> param_rules) { … }

void NetworkServiceTestProxy::AddRules(
    std::vector<RulePtr> in_rules, AddRulesCallback callback) { … }

void NetworkServiceTestProxy::SimulateNetworkChange(
    ::network::mojom::ConnectionType in_type, SimulateNetworkChangeCallback callback) { … }

void NetworkServiceTestProxy::SimulateNetworkQualityChange(
    ::net::EffectiveConnectionType in_type, SimulateNetworkQualityChangeCallback callback) { … }

void NetworkServiceTestProxy::ForceNetworkQualityEstimatorReportWifiAsSlow2G(
    ForceNetworkQualityEstimatorReportWifiAsSlow2GCallback callback) { … }

void NetworkServiceTestProxy::SimulateCrash(
    ) { … }
bool NetworkServiceTestProxy::MockCertVerifierSetDefaultResult(
    int32_t param_default_result) { … }

void NetworkServiceTestProxy::MockCertVerifierSetDefaultResult(
    int32_t in_default_result, MockCertVerifierSetDefaultResultCallback callback) { … }
bool NetworkServiceTestProxy::MockCertVerifierAddResultForCertAndHost(
    const ::scoped_refptr<::net::X509Certificate>& param_cert, const std::string& param_host_pattern, const ::net::CertVerifyResult& param_verify_result, int32_t param_rv) { … }

void NetworkServiceTestProxy::MockCertVerifierAddResultForCertAndHost(
    const ::scoped_refptr<::net::X509Certificate>& in_cert, const std::string& in_host_pattern, const ::net::CertVerifyResult& in_verify_result, int32_t in_rv, MockCertVerifierAddResultForCertAndHostCallback callback) { … }
bool NetworkServiceTestProxy::SetTransportSecurityStateSource(
    uint16_t param_reporting_port) { … }

void NetworkServiceTestProxy::SetTransportSecurityStateSource(
    uint16_t in_reporting_port, SetTransportSecurityStateSourceCallback callback) { … }
bool NetworkServiceTestProxy::SetAllowNetworkAccessToHostResolutions(
    ) { … }

void NetworkServiceTestProxy::SetAllowNetworkAccessToHostResolutions(
    SetAllowNetworkAccessToHostResolutionsCallback callback) { … }
bool NetworkServiceTestProxy::ReplaceSystemDnsConfig(
    ) { … }

void NetworkServiceTestProxy::ReplaceSystemDnsConfig(
    ReplaceSystemDnsConfigCallback callback) { … }
bool NetworkServiceTestProxy::SetTestDohConfig(
    ::net::SecureDnsMode param_secure_dns_mode, const ::net::DnsOverHttpsConfig& param_doh_config) { … }

void NetworkServiceTestProxy::SetTestDohConfig(
    ::net::SecureDnsMode in_secure_dns_mode, const ::net::DnsOverHttpsConfig& in_doh_config, SetTestDohConfigCallback callback) { … }

void NetworkServiceTestProxy::CrashOnResolveHost(
    const std::string& in_host) { … }

void NetworkServiceTestProxy::CrashOnGetCookieList(
    ) { … }
bool NetworkServiceTestProxy::GetLatestMemoryPressureLevel(
    ::base::MemoryPressureListener::MemoryPressureLevel* out_param_memory_pressure_level) { … }

void NetworkServiceTestProxy::GetLatestMemoryPressureLevel(
    GetLatestMemoryPressureLevelCallback callback) { … }
bool NetworkServiceTestProxy::GetPeerToPeerConnectionsCountChange(
    uint32_t* out_param_connection_count) { … }

void NetworkServiceTestProxy::GetPeerToPeerConnectionsCountChange(
    GetPeerToPeerConnectionsCountChangeCallback callback) { … }
bool NetworkServiceTestProxy::GetEnvironmentVariableValue(
    const std::string& param_name, std::string* out_param_value) { … }

void NetworkServiceTestProxy::GetEnvironmentVariableValue(
    const std::string& in_name, GetEnvironmentVariableValueCallback callback) { … }
bool NetworkServiceTestProxy::Log(
    const std::string& param_message) { … }

void NetworkServiceTestProxy::Log(
    const std::string& in_message, LogCallback callback) { … }

void NetworkServiceTestProxy::ActivateFieldTrial(
    const std::string& in_field_trial_name) { … }
bool NetworkServiceTestProxy::SetSCTAuditingRetryDelay(
    std::optional<::base::TimeDelta> param_delay) { … }

void NetworkServiceTestProxy::SetSCTAuditingRetryDelay(
    std::optional<::base::TimeDelta> in_delay, SetSCTAuditingRetryDelayCallback callback) { … }

void NetworkServiceTestProxy::OpenFile(
    const ::base::FilePath& in_path, OpenFileCallback callback) { … }

void NetworkServiceTestProxy::EnumerateFiles(
    const ::base::FilePath& in_path, ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> in_factory, EnumerateFilesCallback callback) { … }

void NetworkServiceTestProxy::CreateSimpleCache(
    ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> in_factory, const ::base::FilePath& in_path, bool in_reset, CreateSimpleCacheCallback callback) { … }

void NetworkServiceTestProxy::MakeRequestToServer(
    ::network::TransferableSocket in_s, const ::net::IPEndPoint& in_endpoint, MakeRequestToServerCallback callback) { … }

void NetworkServiceTestProxy::ResolveOwnHostnameWithSystemDns(
    ResolveOwnHostnameWithSystemDnsCallback callback) { … }

void NetworkServiceTestProxy::SetIPv6ProbeResult(
    bool in_success, SetIPv6ProbeResultCallback callback) { … }
bool NetworkServiceTestProxy::GetAddressMapCacheLinux(
    ::net::AddressMapOwnerLinux::AddressMap* out_param_addr_map, ::std::unordered_set<int>* out_param_links) { … }

void NetworkServiceTestProxy::GetAddressMapCacheLinux(
    GetAddressMapCacheLinuxCallback callback) { … }
bool NetworkServiceTestProxy::AllowsGSSAPILibraryLoad(
    bool* out_param_allow_gssapi_library_load) { … }

void NetworkServiceTestProxy::AllowsGSSAPILibraryLoad(
    AllowsGSSAPILibraryLoadCallback callback) { … }
class NetworkServiceTest_AddRules_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_AddRules_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_AddRules_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_SimulateNetworkChange_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SimulateNetworkChange_ProxyToResponder::Run(
    ) { … }
class NetworkServiceTest_SimulateNetworkQualityChange_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SimulateNetworkQualityChange_ProxyToResponder::Run(
    ) { … }
class NetworkServiceTest_ForceNetworkQualityEstimatorReportWifiAsSlow2G_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_ForceNetworkQualityEstimatorReportWifiAsSlow2G_ProxyToResponder::Run(
    ) { … }
class NetworkServiceTest_MockCertVerifierSetDefaultResult_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_MockCertVerifierSetDefaultResult_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_MockCertVerifierSetDefaultResult_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_MockCertVerifierAddResultForCertAndHost_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_MockCertVerifierAddResultForCertAndHost_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_MockCertVerifierAddResultForCertAndHost_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_SetTransportSecurityStateSource_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SetTransportSecurityStateSource_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_SetTransportSecurityStateSource_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_SetAllowNetworkAccessToHostResolutions_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SetAllowNetworkAccessToHostResolutions_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_SetAllowNetworkAccessToHostResolutions_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_ReplaceSystemDnsConfig_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_ReplaceSystemDnsConfig_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_ReplaceSystemDnsConfig_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_SetTestDohConfig_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SetTestDohConfig_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_SetTestDohConfig_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_GetLatestMemoryPressureLevel_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_GetLatestMemoryPressureLevel_ProxyToResponder::Run(
    ::base::MemoryPressureListener::MemoryPressureLevel in_memory_pressure_level) { … }
bool NetworkServiceTest_GetLatestMemoryPressureLevel_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_GetPeerToPeerConnectionsCountChange_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_GetPeerToPeerConnectionsCountChange_ProxyToResponder::Run(
    uint32_t in_connection_count) { … }
bool NetworkServiceTest_GetPeerToPeerConnectionsCountChange_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_GetEnvironmentVariableValue_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_GetEnvironmentVariableValue_ProxyToResponder::Run(
    const std::string& in_value) { … }
bool NetworkServiceTest_GetEnvironmentVariableValue_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_Log_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_Log_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_Log_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_SetSCTAuditingRetryDelay_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SetSCTAuditingRetryDelay_ProxyToResponder::Run(
    ) { … }
bool NetworkServiceTest_SetSCTAuditingRetryDelay_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_OpenFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_OpenFile_ProxyToResponder::Run(
    bool in_result) { … }
class NetworkServiceTest_EnumerateFiles_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_EnumerateFiles_ProxyToResponder::Run(
    const std::vector<::disk_cache::BackendFileOperations::FileEnumerationEntry>& in_entries, bool in_error) { … }
class NetworkServiceTest_CreateSimpleCache_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_CreateSimpleCache_ProxyToResponder::Run(
    ::mojo::PendingRemote<SimpleCache> in_backend) { … }
class NetworkServiceTest_MakeRequestToServer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_MakeRequestToServer_ProxyToResponder::Run(
    bool in_result) { … }
class NetworkServiceTest_ResolveOwnHostnameWithSystemDns_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_ResolveOwnHostnameWithSystemDns_ProxyToResponder::Run(
    const ::net::AddressList& in_addr_list, int32_t in_os_error, int32_t in_net_error) { … }
class NetworkServiceTest_SetIPv6ProbeResult_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_SetIPv6ProbeResult_ProxyToResponder::Run(
    ) { … }
class NetworkServiceTest_GetAddressMapCacheLinux_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_GetAddressMapCacheLinux_ProxyToResponder::Run(
    const ::net::AddressMapOwnerLinux::AddressMap& in_addr_map, const ::std::unordered_set<int>& in_links) { … }
bool NetworkServiceTest_GetAddressMapCacheLinux_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class NetworkServiceTest_AllowsGSSAPILibraryLoad_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NetworkServiceTest_AllowsGSSAPILibraryLoad_ProxyToResponder::Run(
    bool in_allow_gssapi_library_load) { … }
bool NetworkServiceTest_AllowsGSSAPILibraryLoad_HandleSyncResponse::Accept(
    mojo::Message* message) { … }

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

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

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

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


}  // network::mojom


namespace mojo {


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


// static
bool StructTraits<::network::mojom::SimpleCacheOpenEntryResult::DataView, ::network::mojom::SimpleCacheOpenEntryResultPtr>::Read(
    ::network::mojom::SimpleCacheOpenEntryResult::DataView input,
    ::network::mojom::SimpleCacheOpenEntryResultPtr* 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 SimpleCacheEntryInterceptorForTesting::WriteData(int32_t index, int32_t offset, const std::vector<uint8_t>& data, bool truncate, WriteDataCallback callback) { … }
void SimpleCacheEntryInterceptorForTesting::ReadData(int32_t index, int32_t offset, uint32_t length, ReadDataCallback callback) { … }
void SimpleCacheEntryInterceptorForTesting::WriteSparseData(int32_t offset, const std::vector<uint8_t>& data, WriteSparseDataCallback callback) { … }
void SimpleCacheEntryInterceptorForTesting::ReadSparseData(int32_t offset, uint32_t length, ReadSparseDataCallback callback) { … }
void SimpleCacheEntryInterceptorForTesting::Close(CloseCallback callback) { … }
SimpleCacheEntryAsyncWaiter::SimpleCacheEntryAsyncWaiter(
    SimpleCacheEntry* proxy) : … { … }

SimpleCacheEntryAsyncWaiter::~SimpleCacheEntryAsyncWaiter() = default;

void SimpleCacheEntryAsyncWaiter::WriteData(
    int32_t index, int32_t offset, const std::vector<uint8_t>& data, bool truncate, int32_t* out_result) { … }

int32_t SimpleCacheEntryAsyncWaiter::WriteData(
    int32_t index, int32_t offset, const std::vector<uint8_t>& data, bool truncate) { … }

void SimpleCacheEntryAsyncWaiter::ReadData(
    int32_t index, int32_t offset, uint32_t length, std::vector<uint8_t>* out_data, int32_t* out_result) { … }



void SimpleCacheEntryAsyncWaiter::WriteSparseData(
    int32_t offset, const std::vector<uint8_t>& data, int32_t* out_result) { … }

int32_t SimpleCacheEntryAsyncWaiter::WriteSparseData(
    int32_t offset, const std::vector<uint8_t>& data) { … }

void SimpleCacheEntryAsyncWaiter::ReadSparseData(
    int32_t offset, uint32_t length, std::vector<uint8_t>* out_data, int32_t* out_result) { … }



void SimpleCacheEntryAsyncWaiter::Close(
    ) { … }






void SimpleCacheEntryEnumeratorInterceptorForTesting::GetNext(GetNextCallback callback) { … }
SimpleCacheEntryEnumeratorAsyncWaiter::SimpleCacheEntryEnumeratorAsyncWaiter(
    SimpleCacheEntryEnumerator* proxy) : … { … }

SimpleCacheEntryEnumeratorAsyncWaiter::~SimpleCacheEntryEnumeratorAsyncWaiter() = default;

void SimpleCacheEntryEnumeratorAsyncWaiter::GetNext(
    SimpleCacheOpenEntryResultPtr* out_result) { … }

SimpleCacheOpenEntryResultPtr SimpleCacheEntryEnumeratorAsyncWaiter::GetNext(
    ) { … }




void SimpleCacheInterceptorForTesting::CreateEntry(const std::string& key, CreateEntryCallback callback) { … }
void SimpleCacheInterceptorForTesting::OpenEntry(const std::string& key, OpenEntryCallback callback) { … }
void SimpleCacheInterceptorForTesting::DoomEntry(const std::string& key, DoomEntryCallback callback) { … }
void SimpleCacheInterceptorForTesting::DoomAllEntries(DoomAllEntriesCallback callback) { … }
void SimpleCacheInterceptorForTesting::EnumerateEntries(::mojo::PendingReceiver<SimpleCacheEntryEnumerator> receiver) { … }
void SimpleCacheInterceptorForTesting::Detach(DetachCallback callback) { … }
SimpleCacheAsyncWaiter::SimpleCacheAsyncWaiter(
    SimpleCache* proxy) : … { … }

SimpleCacheAsyncWaiter::~SimpleCacheAsyncWaiter() = default;

void SimpleCacheAsyncWaiter::CreateEntry(
    const std::string& key, ::mojo::PendingRemote<SimpleCacheEntry>* out_entry, int32_t* out_error) { … }



void SimpleCacheAsyncWaiter::OpenEntry(
    const std::string& key, ::mojo::PendingRemote<SimpleCacheEntry>* out_entry, int32_t* out_error) { … }



void SimpleCacheAsyncWaiter::DoomEntry(
    const std::string& key, int32_t* out_result) { … }

int32_t SimpleCacheAsyncWaiter::DoomEntry(
    const std::string& key) { … }

void SimpleCacheAsyncWaiter::DoomAllEntries(
    int32_t* out_result) { … }

int32_t SimpleCacheAsyncWaiter::DoomAllEntries(
    ) { … }

void SimpleCacheAsyncWaiter::Detach(
    ) { … }






void NetworkServiceTestInterceptorForTesting::AddRules(std::vector<RulePtr> rules, AddRulesCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SimulateNetworkChange(::network::mojom::ConnectionType type, SimulateNetworkChangeCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SimulateNetworkQualityChange(::net::EffectiveConnectionType type, SimulateNetworkQualityChangeCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::ForceNetworkQualityEstimatorReportWifiAsSlow2G(ForceNetworkQualityEstimatorReportWifiAsSlow2GCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SimulateCrash() { … }
void NetworkServiceTestInterceptorForTesting::MockCertVerifierSetDefaultResult(int32_t default_result, MockCertVerifierSetDefaultResultCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::MockCertVerifierAddResultForCertAndHost(const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv, MockCertVerifierAddResultForCertAndHostCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SetTransportSecurityStateSource(uint16_t reporting_port, SetTransportSecurityStateSourceCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SetAllowNetworkAccessToHostResolutions(SetAllowNetworkAccessToHostResolutionsCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::ReplaceSystemDnsConfig(ReplaceSystemDnsConfigCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SetTestDohConfig(::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config, SetTestDohConfigCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::CrashOnResolveHost(const std::string& host) { … }
void NetworkServiceTestInterceptorForTesting::CrashOnGetCookieList() { … }
void NetworkServiceTestInterceptorForTesting::GetLatestMemoryPressureLevel(GetLatestMemoryPressureLevelCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::GetPeerToPeerConnectionsCountChange(GetPeerToPeerConnectionsCountChangeCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::GetEnvironmentVariableValue(const std::string& name, GetEnvironmentVariableValueCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::Log(const std::string& message, LogCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::ActivateFieldTrial(const std::string& field_trial_name) { … }
void NetworkServiceTestInterceptorForTesting::SetSCTAuditingRetryDelay(std::optional<::base::TimeDelta> delay, SetSCTAuditingRetryDelayCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::OpenFile(const ::base::FilePath& path, OpenFileCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::EnumerateFiles(const ::base::FilePath& path, ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, EnumerateFilesCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::CreateSimpleCache(::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, const ::base::FilePath& path, bool reset, CreateSimpleCacheCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::MakeRequestToServer(::network::TransferableSocket s, const ::net::IPEndPoint& endpoint, MakeRequestToServerCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::ResolveOwnHostnameWithSystemDns(ResolveOwnHostnameWithSystemDnsCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::SetIPv6ProbeResult(bool success, SetIPv6ProbeResultCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::GetAddressMapCacheLinux(GetAddressMapCacheLinuxCallback callback) { … }
void NetworkServiceTestInterceptorForTesting::AllowsGSSAPILibraryLoad(AllowsGSSAPILibraryLoadCallback callback) { … }
NetworkServiceTestAsyncWaiter::NetworkServiceTestAsyncWaiter(
    NetworkServiceTest* proxy) : … { … }

NetworkServiceTestAsyncWaiter::~NetworkServiceTestAsyncWaiter() = default;

void NetworkServiceTestAsyncWaiter::AddRules(
    std::vector<RulePtr> rules) { … }



void NetworkServiceTestAsyncWaiter::SimulateNetworkChange(
    ::network::mojom::ConnectionType type) { … }



void NetworkServiceTestAsyncWaiter::SimulateNetworkQualityChange(
    ::net::EffectiveConnectionType type) { … }



void NetworkServiceTestAsyncWaiter::ForceNetworkQualityEstimatorReportWifiAsSlow2G(
    ) { … }



void NetworkServiceTestAsyncWaiter::MockCertVerifierSetDefaultResult(
    int32_t default_result) { … }



void NetworkServiceTestAsyncWaiter::MockCertVerifierAddResultForCertAndHost(
    const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv) { … }



void NetworkServiceTestAsyncWaiter::SetTransportSecurityStateSource(
    uint16_t reporting_port) { … }



void NetworkServiceTestAsyncWaiter::SetAllowNetworkAccessToHostResolutions(
    ) { … }



void NetworkServiceTestAsyncWaiter::ReplaceSystemDnsConfig(
    ) { … }



void NetworkServiceTestAsyncWaiter::SetTestDohConfig(
    ::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config) { … }



void NetworkServiceTestAsyncWaiter::GetLatestMemoryPressureLevel(
    ::base::MemoryPressureListener::MemoryPressureLevel* out_memory_pressure_level) { … }

::base::MemoryPressureListener::MemoryPressureLevel NetworkServiceTestAsyncWaiter::GetLatestMemoryPressureLevel(
    ) { … }

void NetworkServiceTestAsyncWaiter::GetPeerToPeerConnectionsCountChange(
    uint32_t* out_connection_count) { … }

uint32_t NetworkServiceTestAsyncWaiter::GetPeerToPeerConnectionsCountChange(
    ) { … }

void NetworkServiceTestAsyncWaiter::GetEnvironmentVariableValue(
    const std::string& name, std::string* out_value) { … }

std::string NetworkServiceTestAsyncWaiter::GetEnvironmentVariableValue(
    const std::string& name) { … }

void NetworkServiceTestAsyncWaiter::Log(
    const std::string& message) { … }



void NetworkServiceTestAsyncWaiter::SetSCTAuditingRetryDelay(
    std::optional<::base::TimeDelta> delay) { … }



void NetworkServiceTestAsyncWaiter::OpenFile(
    const ::base::FilePath& path, bool* out_result) { … }

bool NetworkServiceTestAsyncWaiter::OpenFile(
    const ::base::FilePath& path) { … }

void NetworkServiceTestAsyncWaiter::EnumerateFiles(
    const ::base::FilePath& path, ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, std::vector<::disk_cache::BackendFileOperations::FileEnumerationEntry>* out_entries, bool* out_error) { … }



void NetworkServiceTestAsyncWaiter::CreateSimpleCache(
    ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, const ::base::FilePath& path, bool reset, ::mojo::PendingRemote<SimpleCache>* out_backend) { … }

::mojo::PendingRemote<SimpleCache> NetworkServiceTestAsyncWaiter::CreateSimpleCache(
    ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, const ::base::FilePath& path, bool reset) { … }

void NetworkServiceTestAsyncWaiter::MakeRequestToServer(
    ::network::TransferableSocket s, const ::net::IPEndPoint& endpoint, bool* out_result) { … }

bool NetworkServiceTestAsyncWaiter::MakeRequestToServer(
    ::network::TransferableSocket s, const ::net::IPEndPoint& endpoint) { … }

void NetworkServiceTestAsyncWaiter::ResolveOwnHostnameWithSystemDns(
    ::net::AddressList* out_addr_list, int32_t* out_os_error, int32_t* out_net_error) { … }



void NetworkServiceTestAsyncWaiter::SetIPv6ProbeResult(
    bool success) { … }



void NetworkServiceTestAsyncWaiter::GetAddressMapCacheLinux(
    ::net::AddressMapOwnerLinux::AddressMap* out_addr_map, ::std::unordered_set<int>* out_links) { … }



void NetworkServiceTestAsyncWaiter::AllowsGSSAPILibraryLoad(
    bool* out_allow_gssapi_library_load) { … }

bool NetworkServiceTestAsyncWaiter::AllowsGSSAPILibraryLoad(
    ) { … }






}  // network::mojom


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