net_error_generated.go

// Code generated by cmd/build-naive generate-net-errors. DO NOT EDIT.
// Source: naiveproxy/src/net/base/net_error_list.h

package cronet

// NetError constants from Chromium's net_error_list.h
const (
	NetErrorIOPending                                             NetError = -1
	NetErrorFailed                                                NetError = -2
	NetErrorAborted                                               NetError = -3
	NetErrorInvalidArgument                                       NetError = -4
	NetErrorInvalidHandle                                         NetError = -5
	NetErrorFileNotFound                                          NetError = -6
	NetErrorTimedOut                                              NetError = -7
	NetErrorFileTooBig                                            NetError = -8
	NetErrorUnexpected                                            NetError = -9
	NetErrorAccessDenied                                          NetError = -10
	NetErrorNotImplemented                                        NetError = -11
	NetErrorInsufficientResources                                 NetError = -12
	NetErrorOutOfMemory                                           NetError = -13
	NetErrorUploadFileChanged                                     NetError = -14
	NetErrorSocketNotConnected                                    NetError = -15
	NetErrorFileExists                                            NetError = -16
	NetErrorFilePathTooLong                                       NetError = -17
	NetErrorFileNoSpace                                           NetError = -18
	NetErrorFileVirusInfected                                     NetError = -19
	NetErrorBlockedByClient                                       NetError = -20
	NetErrorNetworkChanged                                        NetError = -21
	NetErrorBlockedByAdministrator                                NetError = -22
	NetErrorSocketIsConnected                                     NetError = -23
	NetErrorUploadStreamRewindNotSupported                        NetError = -25
	NetErrorContextShutDown                                       NetError = -26
	NetErrorBlockedByResponse                                     NetError = -27
	NetErrorCleartextNotPermitted                                 NetError = -29
	NetErrorBlockedByCSP                                          NetError = -30
	NetErrorBlockedByORB                                          NetError = -32
	NetErrorNetworkAccessRevoked                                  NetError = -33
	NetErrorBlockedByFingerprintingProtection                     NetError = -34
	NetErrorBlockedInIncognitoByAdministrator                     NetError = -35
	NetErrorLocalNetworkPermissionMissing                         NetError = -36
	NetErrorStrictECHRequired                                     NetError = -37
	NetErrorConnectionClosed                                      NetError = -100
	NetErrorConnectionReset                                       NetError = -101
	NetErrorConnectionRefused                                     NetError = -102
	NetErrorConnectionAborted                                     NetError = -103
	NetErrorConnectionFailed                                      NetError = -104
	NetErrorNameNotResolved                                       NetError = -105
	NetErrorInternetDisconnected                                  NetError = -106
	NetErrorSSLProtocolError                                      NetError = -107
	NetErrorAddressInvalid                                        NetError = -108
	NetErrorAddressUnreachable                                    NetError = -109
	NetErrorSSLClientAuthCertNeeded                               NetError = -110
	NetErrorTunnelConnectionFailed                                NetError = -111
	NetErrorSSLVersionOrCipherMismatch                            NetError = -113
	NetErrorSSLRenegotiationRequested                             NetError = -114
	NetErrorProxyAuthUnsupported                                  NetError = -115
	NetErrorBadSSLClientAuthCert                                  NetError = -117
	NetErrorConnectionTimedOut                                    NetError = -118
	NetErrorHostResolverQueueTooLarge                             NetError = -119
	NetErrorSOCKSConnectionFailed                                 NetError = -120
	NetErrorSOCKSConnectionHostUnreachable                        NetError = -121
	NetErrorAlpnNegotiationFailed                                 NetError = -122
	NetErrorSSLNoRenegotiation                                    NetError = -123
	NetErrorWinsockUnexpectedWrittenBytes                         NetError = -124
	NetErrorSSLDecompressionFailureAlert                          NetError = -125
	NetErrorSSLBadRecordMACAlert                                  NetError = -126
	NetErrorProxyAuthRequested                                    NetError = -127
	NetErrorProxyConnectionFailed                                 NetError = -130
	NetErrorMandatoryProxyConfigurationFailed                     NetError = -131
	NetErrorPreconnectMaxSocketLimit                              NetError = -133
	NetErrorSSLClientAuthPrivateKeyAccessDenied                   NetError = -134
	NetErrorSSLClientAuthCertNoPrivateKey                         NetError = -135
	NetErrorProxyCertificateInvalid                               NetError = -136
	NetErrorNameResolutionFailed                                  NetError = -137
	NetErrorNetworkAccessDenied                                   NetError = -138
	NetErrorTemporarilyThrottled                                  NetError = -139
	NetErrorSSLClientAuthSignatureFailed                          NetError = -141
	NetErrorMsgTooBig                                             NetError = -142
	NetErrorWsProtocolError                                       NetError = -145
	NetErrorAddressInUse                                          NetError = -147
	NetErrorSSLPinnedKeyNotInCertChain                            NetError = -150
	NetErrorClientAuthCertTypeUnsupported                         NetError = -151
	NetErrorSSLDecryptErrorAlert                                  NetError = -153
	NetErrorWsThrottleQueueTooLarge                               NetError = -154
	NetErrorSSLServerCertChanged                                  NetError = -156
	NetErrorSSLUnrecognizedNameAlert                              NetError = -159
	NetErrorSocketSetReceiveBufferSizeError                       NetError = -160
	NetErrorSocketSetSendBufferSizeError                          NetError = -161
	NetErrorSocketReceiveBufferSizeUnchangeable                   NetError = -162
	NetErrorSocketSendBufferSizeUnchangeable                      NetError = -163
	NetErrorSSLClientAuthCertBadFormat                            NetError = -164
	NetErrorIcannNameCollision                                    NetError = -166
	NetErrorSSLServerCertBadFormat                                NetError = -167
	NetErrorCTSthParsingFailed                                    NetError = -168
	NetErrorCTSthIncomplete                                       NetError = -169
	NetErrorUnableToReuseConnectionForProxyAuth                   NetError = -170
	NetErrorCTConsistencyProofParsingFailed                       NetError = -171
	NetErrorSSLObsoleteCipher                                     NetError = -172
	NetErrorWsUpgrade                                             NetError = -173
	NetErrorReadIfReadyNotImplemented                             NetError = -174
	NetErrorNoBufferSpace                                         NetError = -176
	NetErrorSSLClientAuthNoCommonAlgorithms                       NetError = -177
	NetErrorEarlyDataRejected                                     NetError = -178
	NetErrorWrongVersionOnEarlyData                               NetError = -179
	NetErrorTls13DowngradeDetected                                NetError = -180
	NetErrorSSLKeyUsageIncompatible                               NetError = -181
	NetErrorInvalidECHConfigList                                  NetError = -182
	NetErrorECHNotNegotiated                                      NetError = -183
	NetErrorECHFallbackCertificateInvalid                         NetError = -184
	NetErrorProxyUnableToConnectToDestination                     NetError = -186
	NetErrorProxyDelegateCanceledConnectRequest                   NetError = -187
	NetErrorProxyDelegateCanceledConnectResponse                  NetError = -188
	NetErrorControlMsgTooBig                                      NetError = -189
	NetErrorMulticastNotAllowed                                   NetError = -190
	NetErrorCertCommonNameInvalid                                 NetError = -200
	NetErrorCertDateInvalid                                       NetError = -201
	NetErrorCertAuthorityInvalid                                  NetError = -202
	NetErrorCertContainsErrors                                    NetError = -203
	NetErrorCertNoRevocationMechanism                             NetError = -204
	NetErrorCertUnableToCheckRevocation                           NetError = -205
	NetErrorCertRevoked                                           NetError = -206
	NetErrorCertInvalid                                           NetError = -207
	NetErrorCertWeakSignatureAlgorithm                            NetError = -208
	NetErrorCertNonUniqueName                                     NetError = -210
	NetErrorCertWeakKey                                           NetError = -211
	NetErrorCertNameConstraintViolation                           NetError = -212
	NetErrorCertValidityTooLong                                   NetError = -213
	NetErrorCertificateTransparencyRequired                       NetError = -214
	NetErrorCertKnownInterceptionBlocked                          NetError = -217
	NetErrorCertSelfSignedLocalNetwork                            NetError = -219
	NetErrorInvalidURL                                            NetError = -300
	NetErrorDisallowedURLScheme                                   NetError = -301
	NetErrorUnknownURLScheme                                      NetError = -302
	NetErrorInvalidRedirect                                       NetError = -303
	NetErrorTooManyRedirects                                      NetError = -310
	NetErrorUnsafeRedirect                                        NetError = -311
	NetErrorUnsafePort                                            NetError = -312
	NetErrorInvalidResponse                                       NetError = -320
	NetErrorInvalidChunkedEncoding                                NetError = -321
	NetErrorMethodNotSupported                                    NetError = -322
	NetErrorUnexpectedProxyAuth                                   NetError = -323
	NetErrorEmptyResponse                                         NetError = -324
	NetErrorResponseHeadersTooBig                                 NetError = -325
	NetErrorPACScriptFailed                                       NetError = -327
	NetErrorRequestRangeNotSatisfiable                            NetError = -328
	NetErrorMalformedIdentity                                     NetError = -329
	NetErrorContentDecodingFailed                                 NetError = -330
	NetErrorNetworkIOSuspended                                    NetError = -331
	NetErrorNoSupportedProxies                                    NetError = -336
	NetErrorHTTP2ProtocolError                                    NetError = -337
	NetErrorInvalidAuthCredentials                                NetError = -338
	NetErrorUnsupportedAuthScheme                                 NetError = -339
	NetErrorEncodingDetectionFailed                               NetError = -340
	NetErrorMissingAuthCredentials                                NetError = -341
	NetErrorUnexpectedSecurityLibraryStatus                       NetError = -342
	NetErrorMisconfiguredAuthEnvironment                          NetError = -343
	NetErrorUndocumentedSecurityLibraryStatus                     NetError = -344
	NetErrorResponseBodyTooBigToDrain                             NetError = -345
	NetErrorResponseHeadersMultipleContentLength                  NetError = -346
	NetErrorIncompleteHTTP2Headers                                NetError = -347
	NetErrorPACNotInDhcp                                          NetError = -348
	NetErrorResponseHeadersMultipleContentDisposition             NetError = -349
	NetErrorResponseHeadersMultipleLocation                       NetError = -350
	NetErrorHTTP2ServerRefusedStream                              NetError = -351
	NetErrorHTTP2PingFailed                                       NetError = -352
	NetErrorContentLengthMismatch                                 NetError = -354
	NetErrorIncompleteChunkedEncoding                             NetError = -355
	NetErrorQUICProtocolError                                     NetError = -356
	NetErrorResponseHeadersTruncated                              NetError = -357
	NetErrorQUICHandshakeFailed                                   NetError = -358
	NetErrorHTTP2InadequateTransportSecurity                      NetError = -360
	NetErrorHTTP2FlowControlError                                 NetError = -361
	NetErrorHTTP2FrameSizeError                                   NetError = -362
	NetErrorHTTP2CompressionError                                 NetError = -363
	NetErrorProxyAuthRequestedWithNoConnection                    NetError = -364
	NetErrorHTTP11Required                                        NetError = -365
	NetErrorProxyHTTP11Required                                   NetError = -366
	NetErrorPACScriptTerminated                                   NetError = -367
	NetErrorInvalidHTTPResponse                                   NetError = -370
	NetErrorContentDecodingInitFailed                             NetError = -371
	NetErrorHTTP2RSTStreamNoErrorReceived                         NetError = -372
	NetErrorTooManyRetries                                        NetError = -375
	NetErrorHTTP2StreamClosed                                     NetError = -376
	NetErrorHTTPResponseCodeFailure                               NetError = -379
	NetErrorQUICCertRootNotKnown                                  NetError = -380
	NetErrorQUICGoawayRequestCanBeRetried                         NetError = -381
	NetErrorTooManyAcceptChRestarts                               NetError = -382
	NetErrorInconsistentIPAddressSpace                            NetError = -383
	NetErrorCachedIPAddressSpaceBlockedByLocalNetworkAccessPolicy NetError = -384
	NetErrorBlockedByLocalNetworkAccessChecks                     NetError = -385
	NetErrorZstdWindowSizeTooBig                                  NetError = -386
	NetErrorDictionaryLoadFailed                                  NetError = -387
	NetErrorUnexpectedContentDictionaryHeader                     NetError = -388
	NetErrorCacheMiss                                             NetError = -400
	NetErrorCacheReadFailure                                      NetError = -401
	NetErrorCacheWriteFailure                                     NetError = -402
	NetErrorCacheOperationNotSupported                            NetError = -403
	NetErrorCacheOpenFailure                                      NetError = -404
	NetErrorCacheCreateFailure                                    NetError = -405
	NetErrorCacheRace                                             NetError = -406
	NetErrorCacheChecksumReadFailure                              NetError = -407
	NetErrorCacheChecksumMismatch                                 NetError = -408
	NetErrorCacheLockTimeout                                      NetError = -409
	NetErrorCacheAuthFailureAfterRead                             NetError = -410
	NetErrorCacheEntryNotSuitable                                 NetError = -411
	NetErrorCacheDoomFailure                                      NetError = -412
	NetErrorCacheOpenOrCreateFailure                              NetError = -413
	NetErrorCacheCompressionFailure                               NetError = -414
	NetErrorInsecureResponse                                      NetError = -501
	NetErrorNoPrivateKeyForCert                                   NetError = -502
	NetErrorAddUserCertFailed                                     NetError = -503
	NetErrorInvalidSignedExchange                                 NetError = -504
	NetErrorInvalidWebBundle                                      NetError = -505
	NetErrorTrustTokenOperationFailed                             NetError = -506
	NetErrorTrustTokenOperationSuccessWithoutSendingRequest       NetError = -507
	NetErrorHttpengineProviderInUse                               NetError = -508
	NetErrorPkcs12ImportBadPassword                               NetError = -701
	NetErrorPkcs12ImportFailed                                    NetError = -702
	NetErrorImportCaCertNotCa                                     NetError = -703
	NetErrorImportCertAlreadyExists                               NetError = -704
	NetErrorImportCaCertFailed                                    NetError = -705
	NetErrorImportServerCertFailed                                NetError = -706
	NetErrorPkcs12ImportInvalidMAC                                NetError = -707
	NetErrorPkcs12ImportInvalidFile                               NetError = -708
	NetErrorPkcs12ImportUnsupported                               NetError = -709
	NetErrorKeyGenerationFailed                                   NetError = -710
	NetErrorPrivateKeyExportFailed                                NetError = -712
	NetErrorSelfSignedCertGenerationFailed                        NetError = -713
	NetErrorCertDatabaseChanged                                   NetError = -714
	NetErrorCertVerifierChanged                                   NetError = -716
	NetErrorDNSMalformedResponse                                  NetError = -800
	NetErrorDNSServerRequiresTCP                                  NetError = -801
	NetErrorDNSTimedOut                                           NetError = -803
	NetErrorDNSCacheMiss                                          NetError = -804
	NetErrorDNSSearchEmpty                                        NetError = -805
	NetErrorDNSSortError                                          NetError = -806
	NetErrorDNSSecureResolverHostnameResolutionFailed             NetError = -808
	NetErrorDNSNameHttpsOnly                                      NetError = -809
	NetErrorDNSRequestCancelled                                   NetError = -810
	NetErrorDNSNoMatchingSupportedAlpn                            NetError = -811
	NetErrorDNSSecureProbeRecordInvalid                           NetError = -814
	NetErrorDNSCacheInvalidationInProgress                        NetError = -815
	NetErrorDNSFormatError                                        NetError = -816
	NetErrorDNSServerFailure                                      NetError = -817
	NetErrorDNSNotImplemented                                     NetError = -818
	NetErrorDNSRefused                                            NetError = -819
	NetErrorDNSOtherFailure                                       NetError = -820
	NetErrorDNSDirectOnly                                         NetError = -821
	NetErrorBlobInvalidConstructionArguments                      NetError = -900
	NetErrorBlobOutOfMemory                                       NetError = -901
	NetErrorBlobFileWriteFailed                                   NetError = -902
	NetErrorBlobSourceDiedInTransit                               NetError = -903
	NetErrorBlobDereferencedWhileBuilding                         NetError = -904
	NetErrorBlobReferencedBlobBroken                              NetError = -905
	NetErrorBlobReferencedFileUnavailable                         NetError = -906
)

type netErrorEntry struct {
	code        NetError
	name        string
	message     string
	description string
}

var netErrorInfo = [248]netErrorEntry{
	{NetErrorBlobReferencedFileUnavailable, "ERR_BLOB_REFERENCED_FILE_UNAVAILABLE", "blob referenced file unavailable", "A file that we referenced during construction is not accessible to the renderer trying to create the blob."},
	{NetErrorBlobReferencedBlobBroken, "ERR_BLOB_REFERENCED_BLOB_BROKEN", "blob referenced blob broken", "A blob that we referenced during construction is broken, or a browser-side builder tries to build a blob with a blob reference that isn't finished constructing."},
	{NetErrorBlobDereferencedWhileBuilding, "ERR_BLOB_DEREFERENCED_WHILE_BUILDING", "blob dereferenced while building", "The renderer destructed the blob before it was done transferring, and there were no outstanding references (no one is waiting to read) to keep the blob alive."},
	{NetErrorBlobSourceDiedInTransit, "ERR_BLOB_SOURCE_DIED_IN_TRANSIT", "blob source died in transit", "The renderer was destroyed while data was in transit."},
	{NetErrorBlobFileWriteFailed, "ERR_BLOB_FILE_WRITE_FAILED", "blob file write failed", "We couldn't create or write to a file. File system error, like a full disk."},
	{NetErrorBlobOutOfMemory, "ERR_BLOB_OUT_OF_MEMORY", "blob out of memory", "We don't have enough memory for the blob."},
	{NetErrorBlobInvalidConstructionArguments, "ERR_BLOB_INVALID_CONSTRUCTION_ARGUMENTS", "blob invalid construction arguments", "The following errors are for mapped from a subset of invalid storage::BlobStatus. The construction arguments are invalid. This is considered a bad IPC."},
	{NetErrorDNSDirectOnly, "ERR_DNS_DIRECT_ONLY", "dns direct only", "Declined to call DNS for a direct_only request of a hostname whose traffic would be routed through a proxy."},
	{NetErrorDNSOtherFailure, "ERR_DNS_OTHER_FAILURE", "dns other failure", "The DNS server responded with an rcode indicating that the request failed, but the rcode is not one that we have a specific error code for. In other words, the rcode was not one of the following: - NOERR - FORMERR - SERVFAIL - NXDOMAIN - NOTIMP - REFUSED"},
	{NetErrorDNSRefused, "ERR_DNS_REFUSED", "dns refused", "The DNS server responded that the request was refused."},
	{NetErrorDNSNotImplemented, "ERR_DNS_NOT_IMPLEMENTED", "dns not implemented", "The DNS server responded that the query type is not implemented."},
	{NetErrorDNSServerFailure, "ERR_DNS_SERVER_FAILURE", "dns server failure", "The DNS server responded with a server failure response code."},
	{NetErrorDNSFormatError, "ERR_DNS_FORMAT_ERROR", "dns format error", "The DNS server responded with a format error response code."},
	{NetErrorDNSCacheInvalidationInProgress, "ERR_DNS_CACHE_INVALIDATION_IN_PROGRESS", "dns cache invalidation in progress", "Returned when DNS cache invalidation is in progress. This is a transient error. Callers may want to retry later."},
	{NetErrorDNSSecureProbeRecordInvalid, "ERR_DNS_SECURE_PROBE_RECORD_INVALID", "dns secure probe record invalid", "When checking whether secure DNS can be used, the response returned for the requested probe record either had no answer or was invalid."},
	{NetErrorDNSNoMatchingSupportedAlpn, "ERR_DNS_NO_MATCHING_SUPPORTED_ALPN", "dns no matching supported alpn", "The hostname resolution of HTTPS record was expected to be resolved with alpn values of supported protocols, but did not."},
	{NetErrorDNSRequestCancelled, "ERR_DNS_REQUEST_CANCELLED", "dns request cancelled", "All DNS requests associated with this job have been cancelled."},
	{NetErrorDNSNameHttpsOnly, "ERR_DNS_NAME_HTTPS_ONLY", "dns name https only", "DNS identified the request as disallowed for insecure connection (http/ws). Error should be handled as if an HTTP redirect was received to redirect to https or wss."},
	{NetErrorDNSSecureResolverHostnameResolutionFailed, "ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED", "dns secure resolver hostname resolution failed", "Failed to resolve the hostname of a DNS-over-HTTPS server."},
	{NetErrorDNSSortError, "ERR_DNS_SORT_ERROR", "dns sort error", "Failed to sort addresses according to RFC3484."},
	{NetErrorDNSSearchEmpty, "ERR_DNS_SEARCH_EMPTY", "dns search empty", "Suffix search list rules prevent resolution of the given host name."},
	{NetErrorDNSCacheMiss, "ERR_DNS_CACHE_MISS", "dns cache miss", "The entry was not found in cache or other local sources, for lookups where only local sources were queried. TODO(ericorth): Consider renaming to DNS_LOCAL_MISS or something like that as the cache is not necessarily queried either."},
	{NetErrorDNSTimedOut, "ERR_DNS_TIMED_OUT", "dns timed out", "DNS transaction timed out."},
	{NetErrorDNSServerRequiresTCP, "ERR_DNS_SERVER_REQUIRES_TCP", "dns server requires tcp", "DNS server requires TCP"},
	{NetErrorDNSMalformedResponse, "ERR_DNS_MALFORMED_RESPONSE", "dns malformed response", "DNS error codes. DNS resolver received a malformed response."},
	{NetErrorCertVerifierChanged, "ERR_CERT_VERIFIER_CHANGED", "cert verifier changed", "The certificate verifier configuration changed in some way."},
	{NetErrorCertDatabaseChanged, "ERR_CERT_DATABASE_CHANGED", "cert database changed", "The certificate database changed in some way."},
	{NetErrorSelfSignedCertGenerationFailed, "ERR_SELF_SIGNED_CERT_GENERATION_FAILED", "self signed cert generation failed", "Self-signed certificate generation failed."},
	{NetErrorPrivateKeyExportFailed, "ERR_PRIVATE_KEY_EXPORT_FAILED", "private key export failed", "Failure to export private key."},
	{NetErrorKeyGenerationFailed, "ERR_KEY_GENERATION_FAILED", "key generation failed", "Key generation failed."},
	{NetErrorPkcs12ImportUnsupported, "ERR_PKCS12_IMPORT_UNSUPPORTED", "pkcs12 import unsupported", "PKCS #12 import failed due to unsupported features."},
	{NetErrorPkcs12ImportInvalidFile, "ERR_PKCS12_IMPORT_INVALID_FILE", "pkcs12 import invalid file", "PKCS #12 import failed due to invalid/corrupt file."},
	{NetErrorPkcs12ImportInvalidMAC, "ERR_PKCS12_IMPORT_INVALID_MAC", "pkcs12 import invalid mac", "PKCS #12 import failed due to invalid MAC."},
	{NetErrorImportServerCertFailed, "ERR_IMPORT_SERVER_CERT_FAILED", "import server cert failed", "Server certificate import failed due to some internal error."},
	{NetErrorImportCaCertFailed, "ERR_IMPORT_CA_CERT_FAILED", "import ca cert failed", "CA import failed due to some other error."},
	{NetErrorImportCertAlreadyExists, "ERR_IMPORT_CERT_ALREADY_EXISTS", "import cert already exists", "Import failed - certificate already exists in database. Note it's a little weird this is an error but reimporting a PKCS12 is ok (no-op).  That's how Mozilla does it, though."},
	{NetErrorImportCaCertNotCa, "ERR_IMPORT_CA_CERT_NOT_CA", "import ca cert not ca", "CA import failed - not a CA cert."},
	{NetErrorPkcs12ImportFailed, "ERR_PKCS12_IMPORT_FAILED", "pkcs12 import failed", "PKCS #12 import failed due to other error."},
	{NetErrorPkcs12ImportBadPassword, "ERR_PKCS12_IMPORT_BAD_PASSWORD", "pkcs12 import bad password", "LINT.ThenChange( //components/cronet/android/java/src/org/chromium/net/impl/AndroidNetworkExceptionWrapper.java:HTTPENGINE_PROVIDER_IN_USE, //tools/metrics/histograms/enums.xml:HTTPResponseAndNetErrorCodes, //tools/metrics/histograms/enums.xml:NetErrorCodes, ) LINT.IfChange PKCS #12 import failed due to incorrect password."},
	{NetErrorHttpengineProviderInUse, "ERR_HTTPENGINE_PROVIDER_IN_USE", "httpengine provider in use", "This is a placeholder value that should never be used within //net. When Cronet APIs are being backed by HttpEngine (i.e., HttpEngineProvider is being used), org.chromium.net.NetworkException#getCronetInternalErrorCode is not supported (android.net.http.NetworkException#getCronetInternalErrorCode does not exist). In this scenario, getCronetInternalErrorCode will always return this error. This is a first step towards the deprecation of getCronetInternalErrorCode. Temporarily terminate, then restart, ITTT to avoid unsupported nesting. LINT.ThenChange( //tools/metrics/histograms/enums.xml:HTTPResponseAndNetErrorCodes, //tools/metrics/histograms/enums.xml:NetErrorCodes, ) LINT.IfChange(HTTPENGINE_PROVIDER_IN_USE)"},
	{NetErrorTrustTokenOperationSuccessWithoutSendingRequest, "ERR_TRUST_TOKEN_OPERATION_SUCCESS_WITHOUT_SENDING_REQUEST", "trust token operation success without sending request", "When handling a Trust Tokens protocol operation-executing request, the system was able to execute the request's Trust Tokens operation without sending the request to its destination: for instance, the results could have been present in a local cache (for redemption) or the operation could have been diverted to a local provider (for \"platform-provided\" issuance)."},
	{NetErrorTrustTokenOperationFailed, "ERR_TRUST_TOKEN_OPERATION_FAILED", "trust token operation failed", "A Trust Tokens protocol operation-executing request failed for one of a number of reasons (precondition failure, internal error, bad response)."},
	{NetErrorInvalidWebBundle, "ERR_INVALID_WEB_BUNDLE", "invalid web bundle", "An error occurred while handling a Web Bundle source."},
	{NetErrorInvalidSignedExchange, "ERR_INVALID_SIGNED_EXCHANGE", "invalid signed exchange", "An error occurred while handling a signed exchange."},
	{NetErrorAddUserCertFailed, "ERR_ADD_USER_CERT_FAILED", "add user cert failed", "An error adding a certificate to the OS certificate database."},
	{NetErrorNoPrivateKeyForCert, "ERR_NO_PRIVATE_KEY_FOR_CERT", "no private key for cert", "An attempt to import a client certificate failed, as the user's key database lacked a corresponding private key."},
	{NetErrorInsecureResponse, "ERR_INSECURE_RESPONSE", "insecure response", "The server's response was insecure (e.g. there was a cert error)."},
	{NetErrorCacheCompressionFailure, "ERR_CACHE_COMPRESSION_FAILURE", "cache compression failure", "Zstd compression of a cache entry body failed."},
	{NetErrorCacheOpenOrCreateFailure, "ERR_CACHE_OPEN_OR_CREATE_FAILURE", "cache open or create failure", "The disk cache is unable to open or create this entry."},
	{NetErrorCacheDoomFailure, "ERR_CACHE_DOOM_FAILURE", "cache doom failure", "The disk cache is unable to doom this entry."},
	{NetErrorCacheEntryNotSuitable, "ERR_CACHE_ENTRY_NOT_SUITABLE", "cache entry not suitable", "Internal not-quite error code for the HTTP cache. In-memory hints suggest that the cache entry would not have been usable with the transaction's current configuration (e.g. load flags, mode, etc.)"},
	{NetErrorCacheAuthFailureAfterRead, "ERR_CACHE_AUTH_FAILURE_AFTER_READ", "cache auth failure after read", "Received a challenge after the transaction has read some data, and the credentials aren't available.  There isn't a way to get them at that point."},
	{NetErrorCacheLockTimeout, "ERR_CACHE_LOCK_TIMEOUT", "cache lock timeout", "Internal error code for the HTTP cache. The cache lock timeout has fired."},
	{NetErrorCacheChecksumMismatch, "ERR_CACHE_CHECKSUM_MISMATCH", "cache checksum mismatch", "The cache found an entry with an invalid checksum. This can be returned from attempts to read from the cache. It is an internal error, returned by the SimpleCache backend, but not by any URLRequest methods or members."},
	{NetErrorCacheChecksumReadFailure, "ERR_CACHE_CHECKSUM_READ_FAILURE", "cache checksum read failure", "The cache was unable to read a checksum record on an entry. This can be returned from attempts to read from the cache. It is an internal error, returned by the SimpleCache backend, but not by any URLRequest methods or members."},
	{NetErrorCacheRace, "ERR_CACHE_RACE", "cache race", "Multiple transactions are racing to create disk cache entries. This is an internal error returned from the HttpCache to the HttpCacheTransaction that tells the transaction to restart the entry-creation logic because the state of the cache has changed."},
	{NetErrorCacheCreateFailure, "ERR_CACHE_CREATE_FAILURE", "cache create failure", "The disk cache is unable to create this entry."},
	{NetErrorCacheOpenFailure, "ERR_CACHE_OPEN_FAILURE", "cache open failure", "The disk cache is unable to open this entry."},
	{NetErrorCacheOperationNotSupported, "ERR_CACHE_OPERATION_NOT_SUPPORTED", "cache operation not supported", "The operation is not supported for this entry."},
	{NetErrorCacheWriteFailure, "ERR_CACHE_WRITE_FAILURE", "cache write failure", "Unable to write to the disk cache."},
	{NetErrorCacheReadFailure, "ERR_CACHE_READ_FAILURE", "cache read failure", "Unable to read from the disk cache."},
	{NetErrorCacheMiss, "ERR_CACHE_MISS", "cache miss", "The cache does not have the requested entry."},
	{NetErrorUnexpectedContentDictionaryHeader, "ERR_UNEXPECTED_CONTENT_DICTIONARY_HEADER", "unexpected content dictionary header", "The header of dictionary compressed stream does not match the expected value."},
	{NetErrorDictionaryLoadFailed, "ERR_DICTIONARY_LOAD_FAILED", "dictionary load failed", "The compression dictionary cannot be loaded."},
	{NetErrorZstdWindowSizeTooBig, "ERR_ZSTD_WINDOW_SIZE_TOO_BIG", "zstd window size too big", "Content decoding failed due to the zstd window size being too big (over 8MB)."},
	{NetErrorBlockedByLocalNetworkAccessChecks, "ERR_BLOCKED_BY_LOCAL_NETWORK_ACCESS_CHECKS", "blocked by local network access checks", "The connection is blocked by private network access checks."},
	{NetErrorCachedIPAddressSpaceBlockedByLocalNetworkAccessPolicy, "ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_LOCAL_NETWORK_ACCESS_POLICY", "cached ip address space blocked by local network access policy", "The IP address space of the cached remote endpoint is blocked by private network access check."},
	{NetErrorInconsistentIPAddressSpace, "ERR_INCONSISTENT_IP_ADDRESS_SPACE", "inconsistent ip address space", "The IP address space of the remote endpoint differed from the previous observed value during the same request. Any cache entry for the affected request should be invalidated."},
	{NetErrorTooManyAcceptChRestarts, "ERR_TOO_MANY_ACCEPT_CH_RESTARTS", "too many accept ch restarts", "The ACCEPT_CH restart has been triggered too many times"},
	{NetErrorQUICGoawayRequestCanBeRetried, "ERR_QUIC_GOAWAY_REQUEST_CAN_BE_RETRIED", "quic goaway request can be retried", "A GOAWAY frame has been received indicating that the request has not been processed and is therefore safe to retry on a different connection."},
	{NetErrorQUICCertRootNotKnown, "ERR_QUIC_CERT_ROOT_NOT_KNOWN", "quic cert root not known", "The certificate presented on a QUIC connection does not chain to a known root and the origin connected to is not on a list of domains where unknown roots are allowed."},
	{NetErrorHTTPResponseCodeFailure, "ERR_HTTP_RESPONSE_CODE_FAILURE", "http response code failure", "Obsolete. HTTP/2 push is removed. NET_ERROR(HTTP2_CLIENT_REFUSED_STREAM, -377) Obsolete. HTTP/2 push is removed. NET_ERROR(HTTP2_PUSHED_RESPONSE_DOES_NOT_MATCH, -378) The server returned a non-2xx HTTP response code. Note that this error is only used by certain APIs that interpret the HTTP response itself. URLRequest for instance just passes most non-2xx response back as success."},
	{NetErrorHTTP2StreamClosed, "ERR_HTTP2_STREAM_CLOSED", "http2 stream closed", "Received an HTTP/2 frame on a closed stream."},
	{NetErrorTooManyRetries, "ERR_TOO_MANY_RETRIES", "too many retries", "Obsolete. HTTP/2 push is removed. NET_ERROR(HTTP2_PUSHED_STREAM_NOT_AVAILABLE, -373) Obsolete. HTTP/2 push is removed. NET_ERROR(HTTP2_CLAIMED_PUSHED_STREAM_RESET_BY_SERVER, -374) An HTTP transaction was retried too many times due for authentication or invalid certificates. This may be due to a bug in the net stack that would otherwise infinite loop, or if the server or proxy continually requests fresh credentials or presents a fresh invalid certificate."},
	{NetErrorHTTP2RSTStreamNoErrorReceived, "ERR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED", "http2 rst stream no error received", "Received HTTP/2 RST_STREAM frame with NO_ERROR error code.  This error should be handled internally by HTTP/2 code, and should not make it above the SpdyStream layer."},
	{NetErrorContentDecodingInitFailed, "ERR_CONTENT_DECODING_INIT_FAILED", "content decoding init failed", "Initializing content decoding failed."},
	{NetErrorInvalidHTTPResponse, "ERR_INVALID_HTTP_RESPONSE", "invalid http response", "Obsolete. Support for CNAME record detection was never fully implemented and is no longer needed since the IP Protection feature didn't launch. NET_ERROR(PROXY_REQUIRED, -368) Obsolete. Kept here to avoid reuse. Request is throttled because of a Backoff header. See: crbug.com/486891. NET_ERROR(TEMPORARY_BACKOFF, -369) The server was expected to return an HTTP/1.x response, but did not. Rather than treat it as HTTP/0.9, this error is returned."},
	{NetErrorPACScriptTerminated, "ERR_PAC_SCRIPT_TERMINATED", "pac script terminated", "The PAC script terminated fatally and must be reloaded."},
	{NetErrorProxyHTTP11Required, "ERR_PROXY_HTTP_1_1_REQUIRED", "proxy http 1 1 required", "HTTP_1_1_REQUIRED error code received on HTTP/2 session to proxy."},
	{NetErrorHTTP11Required, "ERR_HTTP_1_1_REQUIRED", "http 1 1 required", "HTTP_1_1_REQUIRED error code received on HTTP/2 session."},
	{NetErrorProxyAuthRequestedWithNoConnection, "ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION", "proxy auth requested with no connection", "Proxy Auth Requested without a valid Client Socket Handle."},
	{NetErrorHTTP2CompressionError, "ERR_HTTP2_COMPRESSION_ERROR", "http2 compression error", "Decoding or encoding of compressed HTTP/2 headers failed."},
	{NetErrorHTTP2FrameSizeError, "ERR_HTTP2_FRAME_SIZE_ERROR", "http2 frame size error", "The peer sent an improperly sized HTTP/2 frame."},
	{NetErrorHTTP2FlowControlError, "ERR_HTTP2_FLOW_CONTROL_ERROR", "http2 flow control error", "The peer violated HTTP/2 flow control."},
	{NetErrorHTTP2InadequateTransportSecurity, "ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY", "http2 inadequate transport security", "Obsolete.  Kept here to avoid reuse, as the old error can still appear on histograms. NET_ERROR(REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC, -359) Transport security is inadequate for the HTTP/2 version."},
	{NetErrorQUICHandshakeFailed, "ERR_QUIC_HANDSHAKE_FAILED", "quic handshake failed", "The QUIC crypto handshake failed.  This means that the server was unable to read any requests sent, so they may be resent."},
	{NetErrorResponseHeadersTruncated, "ERR_RESPONSE_HEADERS_TRUNCATED", "response headers truncated", "The HTTP headers were truncated by an EOF."},
	{NetErrorQUICProtocolError, "ERR_QUIC_PROTOCOL_ERROR", "quic protocol error", "There is a QUIC protocol error."},
	{NetErrorIncompleteChunkedEncoding, "ERR_INCOMPLETE_CHUNKED_ENCODING", "incomplete chunked encoding", "The HTTP response body is transferred with Chunked-Encoding, but the terminating zero-length chunk was never sent when the connection is closed."},
	{NetErrorContentLengthMismatch, "ERR_CONTENT_LENGTH_MISMATCH", "content length mismatch", "Obsolete.  Kept here to avoid reuse, as the old error can still appear on histograms. NET_ERROR(PIPELINE_EVICTION, -353) The HTTP response body transferred fewer bytes than were advertised by the Content-Length header when the connection is closed."},
	{NetErrorHTTP2PingFailed, "ERR_HTTP2_PING_FAILED", "http2 ping failed", "HTTP/2 server didn't respond to the PING message."},
	{NetErrorHTTP2ServerRefusedStream, "ERR_HTTP2_SERVER_REFUSED_STREAM", "http2 server refused stream", "HTTP/2 server refused the request without processing, and sent either a GOAWAY frame with error code NO_ERROR and Last-Stream-ID lower than the stream id corresponding to the request indicating that this request has not been processed yet, or a RST_STREAM frame with error code REFUSED_STREAM. Client MAY retry (on a different connection).  See RFC7540 Section 8.1.4."},
	{NetErrorResponseHeadersMultipleLocation, "ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION", "response headers multiple location", "The HTTP response contained multiple Location headers."},
	{NetErrorResponseHeadersMultipleContentDisposition, "ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION", "response headers multiple content disposition", "The HTTP response contained multiple Content-Disposition headers."},
	{NetErrorPACNotInDhcp, "ERR_PAC_NOT_IN_DHCP", "pac not in dhcp", "No PAC URL configuration could be retrieved from DHCP. This can indicate either a failure to retrieve the DHCP configuration, or that there was no PAC URL configured in DHCP."},
	{NetErrorIncompleteHTTP2Headers, "ERR_INCOMPLETE_HTTP2_HEADERS", "incomplete http2 headers", "HTTP/2 headers have been received, but not all of them - status or version headers are missing, so we're expecting additional frames to complete them."},
	{NetErrorResponseHeadersMultipleContentLength, "ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH", "response headers multiple content length", "The HTTP response contained multiple distinct Content-Length headers."},
	{NetErrorResponseBodyTooBigToDrain, "ERR_RESPONSE_BODY_TOO_BIG_TO_DRAIN", "response body too big to drain", "The HTTP response was too big to drain."},
	{NetErrorUndocumentedSecurityLibraryStatus, "ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS", "undocumented security library status", "An undocumented SSPI or GSSAPI status code was returned."},
	{NetErrorMisconfiguredAuthEnvironment, "ERR_MISCONFIGURED_AUTH_ENVIRONMENT", "misconfigured auth environment", "The environment was not set up correctly for authentication (for example, no KDC could be found or the principal is unknown."},
	{NetErrorUnexpectedSecurityLibraryStatus, "ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS", "unexpected security library status", "An unexpected, but documented, SSPI or GSSAPI status code was returned."},
	{NetErrorMissingAuthCredentials, "ERR_MISSING_AUTH_CREDENTIALS", "missing auth credentials", "(GSSAPI) No Kerberos credentials were available during HTTP Authentication."},
	{NetErrorEncodingDetectionFailed, "ERR_ENCODING_DETECTION_FAILED", "encoding detection failed", "Detecting the encoding of the response failed."},
	{NetErrorUnsupportedAuthScheme, "ERR_UNSUPPORTED_AUTH_SCHEME", "unsupported auth scheme", "An HTTP Authentication scheme was tried which is not supported on this machine."},
	{NetErrorInvalidAuthCredentials, "ERR_INVALID_AUTH_CREDENTIALS", "invalid auth credentials", "Credentials could not be established during HTTP Authentication."},
	{NetErrorHTTP2ProtocolError, "ERR_HTTP2_PROTOCOL_ERROR", "http2 protocol error", "There is an HTTP/2 protocol error."},
	{NetErrorNoSupportedProxies, "ERR_NO_SUPPORTED_PROXIES", "no supported proxies", "Obsolete. This was in earlier SPDY implementations. NET_ERROR(SYN_REPLY_NOT_RECEIVED, -332) Obsolete. These were both used for FTP, which is no longer supported. NET_ERROR(ENCODING_CONVERSION_FAILED, -333) NET_ERROR(UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT, -334) Obsolete. Was only logged in NetLog when an HTTP/2 pushed stream expired. NET_ERROR(INVALID_SPDY_STREAM, -335) There are no supported proxies in the provided list."},
	{NetErrorNetworkIOSuspended, "ERR_NETWORK_IO_SUSPENDED", "network io suspended", "An operation could not be completed because all network IO is suspended."},
	{NetErrorContentDecodingFailed, "ERR_CONTENT_DECODING_FAILED", "content decoding failed", "Content decoding of the response body failed."},
	{NetErrorMalformedIdentity, "ERR_MALFORMED_IDENTITY", "malformed identity", "The identity used for authentication is invalid."},
	{NetErrorRequestRangeNotSatisfiable, "ERR_REQUEST_RANGE_NOT_SATISFIABLE", "request range not satisfiable", "The response was 416 (Requested range not satisfiable) and the server cannot satisfy the range requested."},
	{NetErrorPACScriptFailed, "ERR_PAC_SCRIPT_FAILED", "pac script failed", "The evaluation of the PAC script failed."},
	{NetErrorResponseHeadersTooBig, "ERR_RESPONSE_HEADERS_TOO_BIG", "response headers too big", "The headers section of the response is too large."},
	{NetErrorEmptyResponse, "ERR_EMPTY_RESPONSE", "empty response", "The server closed the connection without sending any data."},
	{NetErrorUnexpectedProxyAuth, "ERR_UNEXPECTED_PROXY_AUTH", "unexpected proxy auth", "The response was 407 (Proxy Authentication Required), yet we did not send the request to a proxy."},
	{NetErrorMethodNotSupported, "ERR_METHOD_NOT_SUPPORTED", "method not supported", "The server did not support the request method."},
	{NetErrorInvalidChunkedEncoding, "ERR_INVALID_CHUNKED_ENCODING", "invalid chunked encoding", "Error in chunked transfer encoding."},
	{NetErrorInvalidResponse, "ERR_INVALID_RESPONSE", "invalid response", "The server's response was invalid."},
	{NetErrorUnsafePort, "ERR_UNSAFE_PORT", "unsafe port", "Attempting to load an URL with an unsafe port number.  These are port numbers that correspond to services, which are not robust to spurious input that may be constructed as a result of an allowed web construct (e.g., HTTP looks a lot like SMTP, so form submission to port 25 is denied)."},
	{NetErrorUnsafeRedirect, "ERR_UNSAFE_REDIRECT", "unsafe redirect", "Attempting to load an URL resulted in an unsafe redirect (e.g., a redirect to file:// is considered unsafe)."},
	{NetErrorTooManyRedirects, "ERR_TOO_MANY_REDIRECTS", "too many redirects", "Attempting to load an URL resulted in too many redirects."},
	{NetErrorInvalidRedirect, "ERR_INVALID_REDIRECT", "invalid redirect", "Attempting to load an URL resulted in a redirect to an invalid URL."},
	{NetErrorUnknownURLScheme, "ERR_UNKNOWN_URL_SCHEME", "unknown url scheme", "The scheme of the URL is unknown."},
	{NetErrorDisallowedURLScheme, "ERR_DISALLOWED_URL_SCHEME", "disallowed url scheme", "The scheme of the URL is disallowed."},
	{NetErrorInvalidURL, "ERR_INVALID_URL", "invalid url", "The URL is invalid."},
	{NetErrorCertSelfSignedLocalNetwork, "ERR_CERT_SELF_SIGNED_LOCAL_NETWORK", "cert self signed local network", "-218 was SSL_OBSOLETE_VERSION which is not longer used. TLS 1.0/1.1 instead cause SSL_VERSION_OR_CIPHER_MISMATCH now. The certificate is self signed and it's being used for either an RFC1918 IP literal URL, or a url ending in .local."},
	{NetErrorCertKnownInterceptionBlocked, "ERR_CERT_KNOWN_INTERCEPTION_BLOCKED", "cert known interception blocked", "-216 was QUIC_CERT_ROOT_NOT_KNOWN which has been renumbered to not be in the certificate error range. The certificate is known to be used for interception by an entity other the device owner."},
	{NetErrorCertificateTransparencyRequired, "ERR_CERTIFICATE_TRANSPARENCY_REQUIRED", "certificate transparency required", "Certificate Transparency was required for this connection, but the server did not provide CT information that complied with the policy."},
	{NetErrorCertValidityTooLong, "ERR_CERT_VALIDITY_TOO_LONG", "cert validity too long", "The certificate's validity period is too long."},
	{NetErrorCertNameConstraintViolation, "ERR_CERT_NAME_CONSTRAINT_VIOLATION", "cert name constraint violation", "The certificate claimed DNS names that are in violation of name constraints."},
	{NetErrorCertWeakKey, "ERR_CERT_WEAK_KEY", "cert weak key", "The server responded with a certificate that contains a weak key (e.g. a too-small RSA key)."},
	{NetErrorCertNonUniqueName, "ERR_CERT_NON_UNIQUE_NAME", "cert non unique name", "-209 is available: was CERT_NOT_IN_DNS. The host name specified in the certificate is not unique."},
	{NetErrorCertWeakSignatureAlgorithm, "ERR_CERT_WEAK_SIGNATURE_ALGORITHM", "cert weak signature algorithm", "The server responded with a certificate that is signed using a weak signature algorithm."},
	{NetErrorCertInvalid, "ERR_CERT_INVALID", "cert invalid", "The server responded with a certificate that is invalid. This error is not recoverable. MSDN describes this error as follows: \"The SSL certificate is invalid.\""},
	{NetErrorCertRevoked, "ERR_CERT_REVOKED", "cert revoked", "The server responded with a certificate has been revoked. We have the capability to ignore this error, but it is probably not the thing to do."},
	{NetErrorCertUnableToCheckRevocation, "ERR_CERT_UNABLE_TO_CHECK_REVOCATION", "cert unable to check revocation", "Revocation information for the security certificate for this site is not available.  This could mean: 1. An attacker has compromised the private key in the certificate and is blocking our attempt to find out that the cert was revoked. 2. The certificate is unrevoked, but the revocation server is busy or unavailable."},
	{NetErrorCertNoRevocationMechanism, "ERR_CERT_NO_REVOCATION_MECHANISM", "cert no revocation mechanism", "The certificate has no mechanism for determining if it is revoked.  In effect, this certificate cannot be revoked."},
	{NetErrorCertContainsErrors, "ERR_CERT_CONTAINS_ERRORS", "cert contains errors", "The server responded with a certificate that contains errors. This error is not recoverable. MSDN describes this error as follows: \"The SSL certificate contains errors.\" NOTE: It's unclear how this differs from ERR_CERT_INVALID. For consistency, use that code instead of this one from now on."},
	{NetErrorCertAuthorityInvalid, "ERR_CERT_AUTHORITY_INVALID", "cert authority invalid", "The server responded with a certificate that is signed by an authority we don't trust.  The could mean: 1. An attacker has substituted the real certificate for a cert that contains their public key and is signed by their cousin. 2. The server operator has a legitimate certificate from a CA we don't know about, but should trust. 3. The server is presenting a self-signed certificate, providing no defense against active attackers (but foiling passive attackers)."},
	{NetErrorCertDateInvalid, "ERR_CERT_DATE_INVALID", "cert date invalid", "The server responded with a certificate that, by our clock, appears to either not yet be valid or to have expired.  This could mean: 1. An attacker is presenting an old certificate for which they have managed to obtain the private key. 2. The server is misconfigured and is not presenting a valid cert. 3. Our clock is wrong."},
	{NetErrorCertCommonNameInvalid, "ERR_CERT_COMMON_NAME_INVALID", "cert common name invalid", "Certificate error codes The values of certificate error codes must be consecutive. The server responded with a certificate whose common name did not match the host name.  This could mean: 1. An attacker has redirected our traffic to their server and is presenting a certificate for which they know the private key. 2. The server is misconfigured and responding with the wrong cert. 3. The user is on a wireless network and is being redirected to the network's login page. 4. The OS has used a DNS search suffix and the server doesn't have a certificate for the abbreviated name in the address bar."},
	{NetErrorMulticastNotAllowed, "ERR_MULTICAST_NOT_ALLOWED", "multicast not allowed", "Direct Sockets attempted to connect to or send a packet to a multicast address without 'direct-sockets-multicast' permissions policy."},
	{NetErrorControlMsgTooBig, "ERR_CONTROL_MSG_TOO_BIG", "control msg too big", "The control message was too large for the transport. (for example a UDP message control data exceeds size threshold)."},
	{NetErrorProxyDelegateCanceledConnectResponse, "ERR_PROXY_DELEGATE_CANCELED_CONNECT_RESPONSE", "proxy delegate canceled connect response", ""},
	{NetErrorProxyDelegateCanceledConnectRequest, "ERR_PROXY_DELEGATE_CANCELED_CONNECT_REQUEST", "proxy delegate canceled connect request", "Some implementations of ProxyDelegate query a separate entity to know whether it should cancel tunnel prior to: - The HTTP CONNECT requests being sent out - The HTTP CONNECT response being parsed by //net An example is CronetProxyDelegate: Cronet allows developers to decide whether the tunnel being established should be canceled."},
	{NetErrorProxyUnableToConnectToDestination, "ERR_PROXY_UNABLE_TO_CONNECT_TO_DESTINATION", "proxy unable to connect to destination", "An attempt to proxy a request failed because the proxy wasn't able to successfully connect to the destination. This likely indicates an issue with the request itself (for instance, the hostname failed to resolve to an IP address or the destination server refused the connection). This error code is used to indicate that the error is outside the control of the proxy server and thus the proxy chain should not be marked as bad. This is in contrast to ERR_TUNNEL_CONNECTION_FAILED which is used for general purpose errors connecting to the proxy and by the proxy request response handling when a proxy delegate doesn't indicate via a different error code whether proxy fallback should occur. Note that for IP Protection proxies this error code causes the proxy to be marked as bad since the preference is to fail open for general purpose errors, but for other proxies this error does not cause the proxy to be marked as bad."},
	{NetErrorECHFallbackCertificateInvalid, "ERR_ECH_FALLBACK_CERTIFICATE_INVALID", "ech fallback certificate invalid", "ECH was enabled, the server was unable to decrypt the encrypted ClientHello, and additionally did not present a certificate valid for the public name."},
	{NetErrorECHNotNegotiated, "ERR_ECH_NOT_NEGOTIATED", "ech not negotiated", "ECH was enabled, but the server was unable to decrypt the encrypted ClientHello."},
	{NetErrorInvalidECHConfigList, "ERR_INVALID_ECH_CONFIG_LIST", "invalid ech config list", "The ECHConfigList fetched over DNS cannot be parsed."},
	{NetErrorSSLKeyUsageIncompatible, "ERR_SSL_KEY_USAGE_INCOMPATIBLE", "ssl key usage incompatible", "The server's certificate has a keyUsage extension incompatible with the negotiated TLS key exchange method."},
	{NetErrorTls13DowngradeDetected, "ERR_TLS13_DOWNGRADE_DETECTED", "tls13 downgrade detected", "TLS 1.3 was enabled, but a lower version was negotiated and the server returned a value indicating it supported TLS 1.3. This is part of a security check in TLS 1.3, but it may also indicate the user is behind a buggy TLS-terminating proxy which implemented TLS 1.2 incorrectly. (See https://crbug.com/boringssl/226.)"},
	{NetErrorWrongVersionOnEarlyData, "ERR_WRONG_VERSION_ON_EARLY_DATA", "wrong version on early data", "TLS 1.3 early data was offered, but the server responded with TLS 1.2 or earlier. This is an internal error code to account for a backwards-compatibility issue with early data and TLS 1.2. It will be received before any data is returned from the socket. The request should be retried with early data disabled. See https://tools.ietf.org/html/rfc8446#appendix-D.3 for details."},
	{NetErrorEarlyDataRejected, "ERR_EARLY_DATA_REJECTED", "early data rejected", "TLS 1.3 early data was rejected by the server. This will be received before any data is returned from the socket. The request should be retried with early data disabled."},
	{NetErrorSSLClientAuthNoCommonAlgorithms, "ERR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS", "ssl client auth no common algorithms", "There were no common signature algorithms between our client certificate private key and the server's preferences."},
	{NetErrorNoBufferSpace, "ERR_NO_BUFFER_SPACE", "no buffer space", "No socket buffer space is available."},
	{NetErrorReadIfReadyNotImplemented, "ERR_READ_IF_READY_NOT_IMPLEMENTED", "read if ready not implemented", "Socket ReadIfReady support is not implemented. This error should not be user visible, because the normal Read() method is used as a fallback."},
	{NetErrorWsUpgrade, "ERR_WS_UPGRADE", "ws upgrade", "When a WebSocket handshake is done successfully and the connection has been upgraded, the URLRequest is cancelled with this error code."},
	{NetErrorSSLObsoleteCipher, "ERR_SSL_OBSOLETE_CIPHER", "ssl obsolete cipher", "The SSL server required an unsupported cipher suite that has since been removed. This error will temporarily be signaled on a fallback for one or two releases immediately following a cipher suite's removal, after which the fallback will be removed."},
	{NetErrorCTConsistencyProofParsingFailed, "ERR_CT_CONSISTENCY_PROOF_PARSING_FAILED", "ct consistency proof parsing failed", "Certificate Transparency: Failed to parse the received consistency proof."},
	{NetErrorUnableToReuseConnectionForProxyAuth, "ERR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH", "unable to reuse connection for proxy auth", "The attempt to reuse a connection to send proxy auth credentials failed before the AuthController was used to generate credentials. The caller should reuse the controller with a new connection. This error is only used internally by the network stack."},
	{NetErrorCTSthIncomplete, "ERR_CT_STH_INCOMPLETE", "ct sth incomplete", "Certificate Transparency: Received a signed tree head whose JSON parsing was OK but was missing some of the fields."},
	{NetErrorCTSthParsingFailed, "ERR_CT_STH_PARSING_FAILED", "ct sth parsing failed", "Certificate Transparency: Received a signed tree head that failed to parse."},
	{NetErrorSSLServerCertBadFormat, "ERR_SSL_SERVER_CERT_BAD_FORMAT", "ssl server cert bad format", "The SSL server presented a certificate which could not be decoded. This is not a certificate error code as no X509Certificate object is available. This error is fatal."},
	{NetErrorIcannNameCollision, "ERR_ICANN_NAME_COLLISION", "icann name collision", "Resolving a hostname to an IP address list included the IPv4 address \"127.0.53.53\". This is a special IP address which ICANN has recommended to indicate there was a name collision, and alert admins to a potential problem."},
	{NetErrorSSLClientAuthCertBadFormat, "ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT", "ssl client auth cert bad format", "Failed to import a client certificate from the platform store into the SSL library."},
	{NetErrorSocketSendBufferSizeUnchangeable, "ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE", "socket send buffer size unchangeable", "Failed to set the socket's send buffer size as requested, despite success return code from setsockopt."},
	{NetErrorSocketReceiveBufferSizeUnchangeable, "ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE", "socket receive buffer size unchangeable", "Failed to set the socket's receive buffer size as requested, despite success return code from setsockopt."},
	{NetErrorSocketSetSendBufferSizeError, "ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR", "socket set send buffer size error", "Failed to set the socket's send buffer size as requested."},
	{NetErrorSocketSetReceiveBufferSizeError, "ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR", "socket set receive buffer size error", "Failed to set the socket's receive buffer size as requested."},
	{NetErrorSSLUnrecognizedNameAlert, "ERR_SSL_UNRECOGNIZED_NAME_ALERT", "ssl unrecognized name alert", "The SSL server sent us a fatal unrecognized_name alert."},
	{NetErrorSSLServerCertChanged, "ERR_SSL_SERVER_CERT_CHANGED", "ssl server cert changed", "The SSL server certificate changed in a renegotiation."},
	{NetErrorWsThrottleQueueTooLarge, "ERR_WS_THROTTLE_QUEUE_TOO_LARGE", "ws throttle queue too large", "There are too many pending WebSocketJob instances, so the new job was not pushed to the queue."},
	{NetErrorSSLDecryptErrorAlert, "ERR_SSL_DECRYPT_ERROR_ALERT", "ssl decrypt error alert", "An SSL peer sent us a fatal decrypt_error alert. This typically occurs when a peer could not correctly verify a signature (in CertificateVerify or ServerKeyExchange) or validate a Finished message."},
	{NetErrorClientAuthCertTypeUnsupported, "ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED", "client auth cert type unsupported", "Server request for client certificate did not contain any types we support."},
	{NetErrorSSLPinnedKeyNotInCertChain, "ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN", "ssl pinned key not in cert chain", "Obsolete: NET_ERROR(SSL_HANDSHAKE_NOT_COMPLETED, -148) NET_ERROR(SSL_BAD_PEER_PUBLIC_KEY, -149) The certificate didn't match the built-in public key pins for the host name. The pins are set in net/http/transport_security_state.cc and require that one of a set of public keys exist on the path from the leaf to the root."},
	{NetErrorAddressInUse, "ERR_ADDRESS_IN_USE", "address in use", "Returned when attempting to bind an address that is already in use."},
	{NetErrorWsProtocolError, "ERR_WS_PROTOCOL_ERROR", "ws protocol error", "Websocket protocol error. Indicates that we are terminating the connection due to a malformed frame or other protocol violation."},
	{NetErrorMsgTooBig, "ERR_MSG_TOO_BIG", "msg too big", "The message was too large for the transport.  (for example a UDP message which exceeds size threshold)."},
	{NetErrorSSLClientAuthSignatureFailed, "ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED", "ssl client auth signature failed", "Obsolete, since we now use the catch-all ERR_TUNNEL_CONNECTION_FAILED when a proxy tried to redirect a request. NET_ERROR(HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT, -140) We were unable to sign the CertificateVerify data of an SSL client auth handshake with the client certificate's private key. Possible causes for this include the user implicitly or explicitly denying access to the private key, the private key may not be valid for signing, the key may be relying on a cached handle which is no longer valid, or the CSP won't allow arbitrary data to be signed."},
	{NetErrorTemporarilyThrottled, "ERR_TEMPORARILY_THROTTLED", "temporarily throttled", "The request throttler module cancelled this request to avoid DDOS."},
	{NetErrorNetworkAccessDenied, "ERR_NETWORK_ACCESS_DENIED", "network access denied", "Permission to access the network was denied. This is used to distinguish errors that were most likely caused by a firewall from other access denied errors. See also ERR_ACCESS_DENIED."},
	{NetErrorNameResolutionFailed, "ERR_NAME_RESOLUTION_FAILED", "name resolution failed", "An error occurred when trying to do a name resolution (DNS)."},
	{NetErrorProxyCertificateInvalid, "ERR_PROXY_CERTIFICATE_INVALID", "proxy certificate invalid", "The certificate presented by the HTTPS Proxy was invalid."},
	{NetErrorSSLClientAuthCertNoPrivateKey, "ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY", "ssl client auth cert no private key", "The SSL client certificate has no private key."},
	{NetErrorSSLClientAuthPrivateKeyAccessDenied, "ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED", "ssl client auth private key access denied", "The permission to use the SSL client certificate's private key was denied."},
	{NetErrorPreconnectMaxSocketLimit, "ERR_PRECONNECT_MAX_SOCKET_LIMIT", "preconnect max socket limit", "-132 was formerly ERR_ESET_ANTI_VIRUS_SSL_INTERCEPTION We've hit the max socket limit for the socket pool while preconnecting.  We don't bother trying to preconnect more sockets."},
	{NetErrorMandatoryProxyConfigurationFailed, "ERR_MANDATORY_PROXY_CONFIGURATION_FAILED", "mandatory proxy configuration failed", "A mandatory proxy configuration could not be used. Currently this means that a mandatory PAC script could not be fetched, parsed or executed."},
	{NetErrorProxyConnectionFailed, "ERR_PROXY_CONNECTION_FAILED", "proxy connection failed", "Could not create a connection to the proxy server. An error occurred either in resolving its name, or in connecting a socket to it. Note that this does NOT include failures during the actual \"CONNECT\" method of an HTTP proxy."},
	{NetErrorProxyAuthRequested, "ERR_PROXY_AUTH_REQUESTED", "proxy auth requested", "The proxy requested authentication (for tunnel establishment)."},
	{NetErrorSSLBadRecordMACAlert, "ERR_SSL_BAD_RECORD_MAC_ALERT", "ssl bad record mac alert", "An SSL peer sent us a fatal bad_record_mac alert. This has been observed from servers with buggy DEFLATE support."},
	{NetErrorSSLDecompressionFailureAlert, "ERR_SSL_DECOMPRESSION_FAILURE_ALERT", "ssl decompression failure alert", "An SSL peer sent us a fatal decompression_failure alert. This typically occurs when a peer selects DEFLATE compression in the mistaken belief that it supports it."},
	{NetErrorWinsockUnexpectedWrittenBytes, "ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES", "winsock unexpected written bytes", "Winsock sometimes reports more data written than passed.  This is probably due to a broken LSP."},
	{NetErrorSSLNoRenegotiation, "ERR_SSL_NO_RENEGOTIATION", "ssl no renegotiation", "The peer sent an SSL no_renegotiation alert message."},
	{NetErrorAlpnNegotiationFailed, "ERR_ALPN_NEGOTIATION_FAILED", "alpn negotiation failed", "The request to negotiate an alternate protocol failed."},
	{NetErrorSOCKSConnectionHostUnreachable, "ERR_SOCKS_CONNECTION_HOST_UNREACHABLE", "socks connection host unreachable", "The SOCKS proxy server failed establishing connection to the target host because that host is unreachable."},
	{NetErrorSOCKSConnectionFailed, "ERR_SOCKS_CONNECTION_FAILED", "socks connection failed", "Failed establishing a connection to the SOCKS proxy server for a target host."},
	{NetErrorHostResolverQueueTooLarge, "ERR_HOST_RESOLVER_QUEUE_TOO_LARGE", "host resolver queue too large", "There are too many pending DNS resolves, so a request in the queue was aborted."},
	{NetErrorConnectionTimedOut, "ERR_CONNECTION_TIMED_OUT", "connection timed out", "A connection attempt timed out."},
	{NetErrorBadSSLClientAuthCert, "ERR_BAD_SSL_CLIENT_AUTH_CERT", "bad ssl client auth cert", "The SSL handshake failed because of a bad or missing client certificate."},
	{NetErrorProxyAuthUnsupported, "ERR_PROXY_AUTH_UNSUPPORTED", "proxy auth unsupported", "The proxy requested authentication (for tunnel establishment) with an unsupported method."},
	{NetErrorSSLRenegotiationRequested, "ERR_SSL_RENEGOTIATION_REQUESTED", "ssl renegotiation requested", "The server requested a renegotiation (rehandshake)."},
	{NetErrorSSLVersionOrCipherMismatch, "ERR_SSL_VERSION_OR_CIPHER_MISMATCH", "ssl version or cipher mismatch", "Obsolete: NET_ERROR(NO_SSL_VERSIONS_ENABLED, -112) The client and server don't support a common SSL protocol version or cipher suite."},
	{NetErrorTunnelConnectionFailed, "ERR_TUNNEL_CONNECTION_FAILED", "tunnel connection failed", "A tunnel connection through the proxy could not be established. For more info see the comment on PROXY_UNABLE_TO_CONNECT_TO_DESTINATION."},
	{NetErrorSSLClientAuthCertNeeded, "ERR_SSL_CLIENT_AUTH_CERT_NEEDED", "ssl client auth cert needed", "The server requested a client certificate for SSL client authentication."},
	{NetErrorAddressUnreachable, "ERR_ADDRESS_UNREACHABLE", "address unreachable", "The IP address is unreachable.  This usually means that there is no route to the specified host or network."},
	{NetErrorAddressInvalid, "ERR_ADDRESS_INVALID", "address invalid", "The IP address or port number is invalid (e.g., cannot connect to the IP address 0 or the port 0)."},
	{NetErrorSSLProtocolError, "ERR_SSL_PROTOCOL_ERROR", "ssl protocol error", "An SSL protocol error occurred."},
	{NetErrorInternetDisconnected, "ERR_INTERNET_DISCONNECTED", "internet disconnected", "The Internet connection has been lost."},
	{NetErrorNameNotResolved, "ERR_NAME_NOT_RESOLVED", "name not resolved", "The host name could not be resolved."},
	{NetErrorConnectionFailed, "ERR_CONNECTION_FAILED", "connection failed", "A connection attempt failed."},
	{NetErrorConnectionAborted, "ERR_CONNECTION_ABORTED", "connection aborted", "A connection timed out as a result of not receiving an ACK for data sent. This can include a FIN packet that did not get ACK'd."},
	{NetErrorConnectionRefused, "ERR_CONNECTION_REFUSED", "connection refused", "A connection attempt was refused."},
	{NetErrorConnectionReset, "ERR_CONNECTION_RESET", "connection reset", "A connection was reset (corresponding to a TCP RST)."},
	{NetErrorConnectionClosed, "ERR_CONNECTION_CLOSED", "connection closed", "A connection was closed (corresponding to a TCP FIN)."},
	{NetErrorStrictECHRequired, "ERR_STRICT_ECH_REQUIRED", "strict ech required", "The request was blocked because ECH is strictly required, but: - The client could not obtain a valid ECH configuration. - The server rejected the ECH, and the client failed to establish a new ECH connection after retrying with retry_configs."},
	{NetErrorLocalNetworkPermissionMissing, "ERR_LOCAL_NETWORK_PERMISSION_MISSING", "local network permission missing", "The request was blocked because the local network permission is missing. Note that this is different from BLOCKED_BY_LOCAL_NETWORK_ACCESS_CHECKS which is specifically for a CORS error code."},
	{NetErrorBlockedInIncognitoByAdministrator, "ERR_BLOCKED_IN_INCOGNITO_BY_ADMINISTRATOR", "blocked in incognito by administrator", "The request was blocked by the Incognito Mode URL block list configured by the domain administrator."},
	{NetErrorBlockedByFingerprintingProtection, "ERR_BLOCKED_BY_FINGERPRINTING_PROTECTION", "blocked by fingerprinting protection", "The request was blocked by fingerprinting protections."},
	{NetErrorNetworkAccessRevoked, "ERR_NETWORK_ACCESS_REVOKED", "network access revoked", "The request was blocked because it originated from a frame that has disabled network access."},
	{NetErrorBlockedByORB, "ERR_BLOCKED_BY_ORB", "blocked by orb", "The request was blocked because of no H/2 or QUIC session. The request was blocked by CORB or ORB."},
	{NetErrorBlockedByCSP, "ERR_BLOCKED_BY_CSP", "blocked by csp", "The request was blocked by a Content Security Policy"},
	{NetErrorCleartextNotPermitted, "ERR_CLEARTEXT_NOT_PERMITTED", "cleartext not permitted", "The request was blocked by system policy disallowing some or all cleartext requests. Used for NetworkSecurityPolicy on Android."},
	{NetErrorBlockedByResponse, "ERR_BLOCKED_BY_RESPONSE", "blocked by response", "The request failed because the response was delivered along with requirements which are not met ('X-Frame-Options' and 'Content-Security-Policy' ancestor checks and 'Cross-Origin-Resource-Policy' for instance)."},
	{NetErrorContextShutDown, "ERR_CONTEXT_SHUT_DOWN", "context shut down", "The request failed because the URLRequestContext is shutting down, or has been shut down."},
	{NetErrorUploadStreamRewindNotSupported, "ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED", "upload stream rewind not supported", "The upload failed because the upload stream needed to be re-read, due to a retry or a redirect, but the upload stream doesn't support that operation."},
	{NetErrorSocketIsConnected, "ERR_SOCKET_IS_CONNECTED", "socket is connected", "The socket is already connected."},
	{NetErrorBlockedByAdministrator, "ERR_BLOCKED_BY_ADMINISTRATOR", "blocked by administrator", "The request was blocked by the URL block list configured by the domain administrator."},
	{NetErrorNetworkChanged, "ERR_NETWORK_CHANGED", "network changed", "The network changed."},
	{NetErrorBlockedByClient, "ERR_BLOCKED_BY_CLIENT", "blocked by client", "The client chose to block the request."},
	{NetErrorFileVirusInfected, "ERR_FILE_VIRUS_INFECTED", "file virus infected", "The file has a virus."},
	{NetErrorFileNoSpace, "ERR_FILE_NO_SPACE", "file no space", "Not enough room left on the disk."},
	{NetErrorFilePathTooLong, "ERR_FILE_PATH_TOO_LONG", "file path too long", "The path or file name is too long."},
	{NetErrorFileExists, "ERR_FILE_EXISTS", "file exists", "The file already exists."},
	{NetErrorSocketNotConnected, "ERR_SOCKET_NOT_CONNECTED", "socket not connected", "The socket is not connected."},
	{NetErrorUploadFileChanged, "ERR_UPLOAD_FILE_CHANGED", "upload file changed", "The file upload failed because the file's modification time was different from the expectation."},
	{NetErrorOutOfMemory, "ERR_OUT_OF_MEMORY", "out of memory", "Memory allocation failed."},
	{NetErrorInsufficientResources, "ERR_INSUFFICIENT_RESOURCES", "insufficient resources", "There were not enough resources to complete the operation."},
	{NetErrorNotImplemented, "ERR_NOT_IMPLEMENTED", "not implemented", "The operation failed because of unimplemented functionality."},
	{NetErrorAccessDenied, "ERR_ACCESS_DENIED", "access denied", "Permission to access a resource, other than the network, was denied."},
	{NetErrorUnexpected, "ERR_UNEXPECTED", "unexpected", "An unexpected error.  This may be caused by a programming mistake or an invalid assumption."},
	{NetErrorFileTooBig, "ERR_FILE_TOO_BIG", "file too big", "The file is too large."},
	{NetErrorTimedOut, "ERR_TIMED_OUT", "timed out", "An operation timed out."},
	{NetErrorFileNotFound, "ERR_FILE_NOT_FOUND", "file not found", "The file or directory cannot be found."},
	{NetErrorInvalidHandle, "ERR_INVALID_HANDLE", "invalid handle", "The handle or file descriptor is invalid."},
	{NetErrorInvalidArgument, "ERR_INVALID_ARGUMENT", "invalid argument", "An argument to the function is incorrect."},
	{NetErrorAborted, "ERR_ABORTED", "aborted", "An operation was aborted (due to user action)."},
	{NetErrorFailed, "ERR_FAILED", "failed", "A generic failure occurred."},
	{NetErrorIOPending, "ERR_IO_PENDING", "io pending", "Copyright 2012 The Chromium Authors Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. This file intentionally does not have header guards, it's included inside a macro to generate enum values. The following line silences a presubmit and Tricium warning that would otherwise be triggered by this: This file contains the list of network errors. LINT.IfChange An asynchronous IO operation is not yet complete.  This usually does not indicate a fatal error.  Typically this error will be generated as a notification to wait for some external notification that the IO operation finally completed."},
}