#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif
#include "services/network/public/mojom/url_loader_network_service_observer.mojom-blink.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/url_loader_network_service_observer.mojom-params-data.h"
#include "services/network/public/mojom/url_loader_network_service_observer.mojom-shared-message-ids.h"
#include "services/network/public/mojom/url_loader_network_service_observer.mojom-blink-import-headers.h"
#include "services/network/public/mojom/url_loader_network_service_observer.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"
namespace network::mojom::blink {
LoadInfo::LoadInfo()
: … { … }
LoadInfo::LoadInfo(
::base::TimeTicks timestamp_in,
const WTF::String& host_in,
uint32_t load_state_in,
const ::WTF::String& state_param_in,
uint64_t upload_position_in,
uint64_t upload_size_in)
: … { … }
LoadInfo::~LoadInfo() = default;
void LoadInfo::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool LoadInfo::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
SharedStorageOperation::SharedStorageOperation()
: … { … }
SharedStorageOperation::SharedStorageOperation(
SharedStorageOperationType type_in,
const WTF::String& key_in,
const WTF::String& value_in,
::network::mojom::blink::OptionalBool ignore_if_present_in)
: … { … }
SharedStorageOperation::~SharedStorageOperation() = default;
void SharedStorageOperation::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool SharedStorageOperation::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
const char ClientCertificateResponder::Name_[] = …;
ClientCertificateResponder::IPCStableHashFunction ClientCertificateResponder::MessageToMethodInfo_(mojo::Message& message) { … }
const char* ClientCertificateResponder::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ClientCertificateResponder::ContinueWithCertificate_Sym::IPCStableHash() { … }
uint32_t ClientCertificateResponder::ContinueWithoutCertificate_Sym::IPCStableHash() { … }
uint32_t ClientCertificateResponder::CancelRequest_Sym::IPCStableHash() { … }
# endif
ClientCertificateResponderProxy::ClientCertificateResponderProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void ClientCertificateResponderProxy::ContinueWithCertificate(
::network::mojom::blink::X509CertificatePtr in_x509_certificate, const WTF::String& in_provider_name, const WTF::Vector<uint16_t>& in_algorithm_preferences, ::mojo::PendingRemote<SSLPrivateKey> in_ssl_private_key) { … }
void ClientCertificateResponderProxy::ContinueWithoutCertificate(
) { … }
void ClientCertificateResponderProxy::CancelRequest(
) { … }
bool ClientCertificateResponderStubDispatch::Accept(
ClientCertificateResponder* impl,
mojo::Message* message) { … }
bool ClientCertificateResponderStubDispatch::AcceptWithResponder(
ClientCertificateResponder* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kClientCertificateResponderValidationInfo[] = …;
bool ClientCertificateResponderRequestValidator::Accept(mojo::Message* message) { … }
const char SSLPrivateKey::Name_[] = …;
SSLPrivateKey::IPCStableHashFunction SSLPrivateKey::MessageToMethodInfo_(mojo::Message& message) { … }
const char* SSLPrivateKey::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SSLPrivateKey::Sign_Sym::IPCStableHash() { … }
# endif
class SSLPrivateKey_Sign_ForwardToCallback
: public mojo::MessageReceiver { … };
SSLPrivateKeyProxy::SSLPrivateKeyProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void SSLPrivateKeyProxy::Sign(
uint16_t in_algorithm, const WTF::Vector<uint8_t>& in_input, SignCallback callback) { … }
class SSLPrivateKey_Sign_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool SSLPrivateKey_Sign_ForwardToCallback::Accept(
mojo::Message* message) { … }
void SSLPrivateKey_Sign_ProxyToResponder::Run(
int32_t in_net_error, const WTF::Vector<uint8_t>& in_signature) { … }
bool SSLPrivateKeyStubDispatch::Accept(
SSLPrivateKey* impl,
mojo::Message* message) { … }
bool SSLPrivateKeyStubDispatch::AcceptWithResponder(
SSLPrivateKey* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kSSLPrivateKeyValidationInfo[] = …;
bool SSLPrivateKeyRequestValidator::Accept(mojo::Message* message) { … }
bool SSLPrivateKeyResponseValidator::Accept(mojo::Message* message) { … }
const char AuthChallengeResponder::Name_[] = …;
AuthChallengeResponder::IPCStableHashFunction AuthChallengeResponder::MessageToMethodInfo_(mojo::Message& message) { … }
const char* AuthChallengeResponder::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t AuthChallengeResponder::OnAuthCredentials_Sym::IPCStableHash() { … }
# endif
AuthChallengeResponderProxy::AuthChallengeResponderProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void AuthChallengeResponderProxy::OnAuthCredentials(
::network::mojom::blink::AuthCredentialsPtr in_credentials) { … }
bool AuthChallengeResponderStubDispatch::Accept(
AuthChallengeResponder* impl,
mojo::Message* message) { … }
bool AuthChallengeResponderStubDispatch::AcceptWithResponder(
AuthChallengeResponder* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kAuthChallengeResponderValidationInfo[] = …;
bool AuthChallengeResponderRequestValidator::Accept(mojo::Message* message) { … }
const char URLLoaderNetworkServiceObserver::Name_[] = …;
URLLoaderNetworkServiceObserver::IPCStableHashFunction URLLoaderNetworkServiceObserver::MessageToMethodInfo_(mojo::Message& message) { … }
const char* URLLoaderNetworkServiceObserver::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t URLLoaderNetworkServiceObserver::OnSSLCertificateError_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnCertificateRequested_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnAuthRequired_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnPrivateNetworkAccessPermissionRequired_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnClearSiteData_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnLoadingStateUpdate_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnDataUseUpdate_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnSharedStorageHeaderReceived_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::Clone_Sym::IPCStableHash() { … }
uint32_t URLLoaderNetworkServiceObserver::OnWebSocketConnectedToPrivateNetwork_Sym::IPCStableHash() { … }
# endif
class URLLoaderNetworkServiceObserver_OnSSLCertificateError_ForwardToCallback
: public mojo::MessageReceiver { … };
class URLLoaderNetworkServiceObserver_OnPrivateNetworkAccessPermissionRequired_ForwardToCallback
: public mojo::MessageReceiver { … };
class URLLoaderNetworkServiceObserver_OnClearSiteData_ForwardToCallback
: public mojo::MessageReceiver { … };
class URLLoaderNetworkServiceObserver_OnLoadingStateUpdate_ForwardToCallback
: public mojo::MessageReceiver { … };
class URLLoaderNetworkServiceObserver_OnSharedStorageHeaderReceived_ForwardToCallback
: public mojo::MessageReceiver { … };
URLLoaderNetworkServiceObserverProxy::URLLoaderNetworkServiceObserverProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void URLLoaderNetworkServiceObserverProxy::OnSSLCertificateError(
const ::blink::KURL& in_url, int32_t in_net_error, ::network::mojom::blink::SSLInfoPtr in_ssl_info, bool in_fatal, OnSSLCertificateErrorCallback callback) { … }
void URLLoaderNetworkServiceObserverProxy::OnCertificateRequested(
const std::optional<::base::UnguessableToken>& in_window_id, ::network::mojom::blink::SSLCertRequestInfoPtr in_cert_info, ::mojo::PendingRemote<ClientCertificateResponder> in_cert_responder) { … }
void URLLoaderNetworkServiceObserverProxy::OnAuthRequired(
const std::optional<::base::UnguessableToken>& in_window_id, int32_t in_request_id, const ::blink::KURL& in_url, bool in_first_auth_attempt, const ::net::AuthChallengeInfo& in_auth_info, ::network::mojom::blink::HttpResponseHeadersPtr in_head_headers, ::mojo::PendingRemote<AuthChallengeResponder> in_auth_challenge_responder) { … }
void URLLoaderNetworkServiceObserverProxy::OnPrivateNetworkAccessPermissionRequired(
const ::blink::KURL& in_url, const ::net::IPAddress& in_ip_address, const WTF::String& in_private_network_device_id, const WTF::String& in_private_network_device_name, OnPrivateNetworkAccessPermissionRequiredCallback callback) { … }
void URLLoaderNetworkServiceObserverProxy::OnClearSiteData(
const ::blink::KURL& in_url, const WTF::String& in_header_value, int32_t in_load_flags, ::network::mojom::blink::CookiePartitionKeyPtr in_cookie_partition_key, bool in_partitioned_state_allowed_only, OnClearSiteDataCallback callback) { … }
void URLLoaderNetworkServiceObserverProxy::OnLoadingStateUpdate(
LoadInfoPtr in_info, OnLoadingStateUpdateCallback callback) { … }
void URLLoaderNetworkServiceObserverProxy::OnDataUseUpdate(
int32_t in_network_traffic_annotation_id_hash, int64_t in_recv_bytes, int64_t in_sent_bytes) { … }
void URLLoaderNetworkServiceObserverProxy::OnSharedStorageHeaderReceived(
const ::scoped_refptr<const ::blink::SecurityOrigin>& in_request_origin, WTF::Vector<SharedStorageOperationPtr> in_operations, OnSharedStorageHeaderReceivedCallback callback) { … }
void URLLoaderNetworkServiceObserverProxy::Clone(
::mojo::PendingReceiver<URLLoaderNetworkServiceObserver> in_listener) { … }
void URLLoaderNetworkServiceObserverProxy::OnWebSocketConnectedToPrivateNetwork(
::network::mojom::blink::IPAddressSpace in_ip_address_space) { … }
class URLLoaderNetworkServiceObserver_OnSSLCertificateError_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool URLLoaderNetworkServiceObserver_OnSSLCertificateError_ForwardToCallback::Accept(
mojo::Message* message) { … }
void URLLoaderNetworkServiceObserver_OnSSLCertificateError_ProxyToResponder::Run(
int32_t in_net_error) { … }
class URLLoaderNetworkServiceObserver_OnPrivateNetworkAccessPermissionRequired_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool URLLoaderNetworkServiceObserver_OnPrivateNetworkAccessPermissionRequired_ForwardToCallback::Accept(
mojo::Message* message) { … }
void URLLoaderNetworkServiceObserver_OnPrivateNetworkAccessPermissionRequired_ProxyToResponder::Run(
bool in_permission_granted) { … }
class URLLoaderNetworkServiceObserver_OnClearSiteData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool URLLoaderNetworkServiceObserver_OnClearSiteData_ForwardToCallback::Accept(
mojo::Message* message) { … }
void URLLoaderNetworkServiceObserver_OnClearSiteData_ProxyToResponder::Run(
) { … }
class URLLoaderNetworkServiceObserver_OnLoadingStateUpdate_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool URLLoaderNetworkServiceObserver_OnLoadingStateUpdate_ForwardToCallback::Accept(
mojo::Message* message) { … }
void URLLoaderNetworkServiceObserver_OnLoadingStateUpdate_ProxyToResponder::Run(
) { … }
class URLLoaderNetworkServiceObserver_OnSharedStorageHeaderReceived_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool URLLoaderNetworkServiceObserver_OnSharedStorageHeaderReceived_ForwardToCallback::Accept(
mojo::Message* message) { … }
void URLLoaderNetworkServiceObserver_OnSharedStorageHeaderReceived_ProxyToResponder::Run(
) { … }
bool URLLoaderNetworkServiceObserverStubDispatch::Accept(
URLLoaderNetworkServiceObserver* impl,
mojo::Message* message) { … }
bool URLLoaderNetworkServiceObserverStubDispatch::AcceptWithResponder(
URLLoaderNetworkServiceObserver* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kURLLoaderNetworkServiceObserverValidationInfo[] = …;
bool URLLoaderNetworkServiceObserverRequestValidator::Accept(mojo::Message* message) { … }
bool URLLoaderNetworkServiceObserverResponseValidator::Accept(mojo::Message* message) { … }
}
namespace mojo {
bool StructTraits<::network::mojom::blink::LoadInfo::DataView, ::network::mojom::blink::LoadInfoPtr>::Read(
::network::mojom::blink::LoadInfo::DataView input,
::network::mojom::blink::LoadInfoPtr* output) { … }
bool StructTraits<::network::mojom::blink::SharedStorageOperation::DataView, ::network::mojom::blink::SharedStorageOperationPtr>::Read(
::network::mojom::blink::SharedStorageOperation::DataView input,
::network::mojom::blink::SharedStorageOperationPtr* output) { … }
}
namespace network::mojom::blink {
void ClientCertificateResponderInterceptorForTesting::ContinueWithCertificate(::network::mojom::blink::X509CertificatePtr x509_certificate, const WTF::String& provider_name, const WTF::Vector<uint16_t>& algorithm_preferences, ::mojo::PendingRemote<SSLPrivateKey> ssl_private_key) { … }
void ClientCertificateResponderInterceptorForTesting::ContinueWithoutCertificate() { … }
void ClientCertificateResponderInterceptorForTesting::CancelRequest() { … }
ClientCertificateResponderAsyncWaiter::ClientCertificateResponderAsyncWaiter(
ClientCertificateResponder* proxy) : … { … }
ClientCertificateResponderAsyncWaiter::~ClientCertificateResponderAsyncWaiter() = default;
void SSLPrivateKeyInterceptorForTesting::Sign(uint16_t algorithm, const WTF::Vector<uint8_t>& input, SignCallback callback) { … }
SSLPrivateKeyAsyncWaiter::SSLPrivateKeyAsyncWaiter(
SSLPrivateKey* proxy) : … { … }
SSLPrivateKeyAsyncWaiter::~SSLPrivateKeyAsyncWaiter() = default;
void SSLPrivateKeyAsyncWaiter::Sign(
uint16_t algorithm, const WTF::Vector<uint8_t>& input, int32_t* out_net_error, WTF::Vector<uint8_t>* out_signature) { … }
void AuthChallengeResponderInterceptorForTesting::OnAuthCredentials(::network::mojom::blink::AuthCredentialsPtr credentials) { … }
AuthChallengeResponderAsyncWaiter::AuthChallengeResponderAsyncWaiter(
AuthChallengeResponder* proxy) : … { … }
AuthChallengeResponderAsyncWaiter::~AuthChallengeResponderAsyncWaiter() = default;
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnSSLCertificateError(const ::blink::KURL& url, int32_t net_error, ::network::mojom::blink::SSLInfoPtr ssl_info, bool fatal, OnSSLCertificateErrorCallback callback) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnCertificateRequested(const std::optional<::base::UnguessableToken>& window_id, ::network::mojom::blink::SSLCertRequestInfoPtr cert_info, ::mojo::PendingRemote<ClientCertificateResponder> cert_responder) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnAuthRequired(const std::optional<::base::UnguessableToken>& window_id, int32_t request_id, const ::blink::KURL& url, bool first_auth_attempt, const ::net::AuthChallengeInfo& auth_info, ::network::mojom::blink::HttpResponseHeadersPtr head_headers, ::mojo::PendingRemote<AuthChallengeResponder> auth_challenge_responder) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnPrivateNetworkAccessPermissionRequired(const ::blink::KURL& url, const ::net::IPAddress& ip_address, const WTF::String& private_network_device_id, const WTF::String& private_network_device_name, OnPrivateNetworkAccessPermissionRequiredCallback callback) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnClearSiteData(const ::blink::KURL& url, const WTF::String& header_value, int32_t load_flags, ::network::mojom::blink::CookiePartitionKeyPtr cookie_partition_key, bool partitioned_state_allowed_only, OnClearSiteDataCallback callback) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnLoadingStateUpdate(LoadInfoPtr info, OnLoadingStateUpdateCallback callback) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnDataUseUpdate(int32_t network_traffic_annotation_id_hash, int64_t recv_bytes, int64_t sent_bytes) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnSharedStorageHeaderReceived(const ::scoped_refptr<const ::blink::SecurityOrigin>& request_origin, WTF::Vector<SharedStorageOperationPtr> operations, OnSharedStorageHeaderReceivedCallback callback) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::Clone(::mojo::PendingReceiver<URLLoaderNetworkServiceObserver> listener) { … }
void URLLoaderNetworkServiceObserverInterceptorForTesting::OnWebSocketConnectedToPrivateNetwork(::network::mojom::blink::IPAddressSpace ip_address_space) { … }
URLLoaderNetworkServiceObserverAsyncWaiter::URLLoaderNetworkServiceObserverAsyncWaiter(
URLLoaderNetworkServiceObserver* proxy) : … { … }
URLLoaderNetworkServiceObserverAsyncWaiter::~URLLoaderNetworkServiceObserverAsyncWaiter() = default;
void URLLoaderNetworkServiceObserverAsyncWaiter::OnSSLCertificateError(
const ::blink::KURL& url, int32_t net_error, ::network::mojom::blink::SSLInfoPtr ssl_info, bool fatal, int32_t* out_net_error) { … }
int32_t URLLoaderNetworkServiceObserverAsyncWaiter::OnSSLCertificateError(
const ::blink::KURL& url, int32_t net_error, ::network::mojom::blink::SSLInfoPtr ssl_info, bool fatal) { … }
void URLLoaderNetworkServiceObserverAsyncWaiter::OnPrivateNetworkAccessPermissionRequired(
const ::blink::KURL& url, const ::net::IPAddress& ip_address, const WTF::String& private_network_device_id, const WTF::String& private_network_device_name, bool* out_permission_granted) { … }
bool URLLoaderNetworkServiceObserverAsyncWaiter::OnPrivateNetworkAccessPermissionRequired(
const ::blink::KURL& url, const ::net::IPAddress& ip_address, const WTF::String& private_network_device_id, const WTF::String& private_network_device_name) { … }
void URLLoaderNetworkServiceObserverAsyncWaiter::OnClearSiteData(
const ::blink::KURL& url, const WTF::String& header_value, int32_t load_flags, ::network::mojom::blink::CookiePartitionKeyPtr cookie_partition_key, bool partitioned_state_allowed_only) { … }
void URLLoaderNetworkServiceObserverAsyncWaiter::OnLoadingStateUpdate(
LoadInfoPtr info) { … }
void URLLoaderNetworkServiceObserverAsyncWaiter::OnSharedStorageHeaderReceived(
const ::scoped_refptr<const ::blink::SecurityOrigin>& request_origin, WTF::Vector<SharedStorageOperationPtr> operations) { … }
}
#if defined(__clang__)
#pragma clang diagnostic pop
#endif