Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(642)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: mojo/services/network/net_adapters.cc

Issue 933973002: Return errors from the Mojo network service using an enum. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Address James's remarks, add missing errors. Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « mojo/services/html_viewer/weburlloader_impl.cc ('k') | mojo/services/network/public/interfaces/network_error.mojom » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/services/network/net_adapters.cc
diff --git a/mojo/services/network/net_adapters.cc b/mojo/services/network/net_adapters.cc
index 551481d38810370c9968a546fdf5492b2896ab27..5bff8b5b8dbb98f4017b4388cc822f45c72ef14b 100644
--- a/mojo/services/network/net_adapters.cc
+++ b/mojo/services/network/net_adapters.cc
@@ -108,8 +108,664 @@ MojoToNetIOBuffer::~MojoToNetIOBuffer() {
// -----------------------------------------------------------------------------
NetworkErrorPtr MakeNetworkError(int error_code) {
+ // The NetworkCode enum values defined in network_error.mojom should match net
+ // error codes from net/net_errors.h.
qsr 2015/02/19 14:27:00 Could you use the include + macro mechanism to do
ppi 2015/02/19 15:36:09 Done. As discussed in person, it's not clear if ty
+ static_assert(NETWORK_CODE_OK == static_cast<NetworkCode>(net::OK),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_IO_PENDING == static_cast<NetworkCode>(net::ERR_IO_PENDING),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_FAILED == static_cast<NetworkCode>(net::ERR_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_ABORTED == static_cast<NetworkCode>(net::ERR_ABORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_ARGUMENT ==
+ static_cast<NetworkCode>(net::ERR_INVALID_ARGUMENT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_HANDLE ==
+ static_cast<NetworkCode>(net::ERR_INVALID_HANDLE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FILE_NOT_FOUND ==
+ static_cast<NetworkCode>(net::ERR_FILE_NOT_FOUND),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_TIMED_OUT == static_cast<NetworkCode>(net::ERR_TIMED_OUT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FILE_TOO_BIG ==
+ static_cast<NetworkCode>(net::ERR_FILE_TOO_BIG),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_UNEXPECTED == static_cast<NetworkCode>(net::ERR_UNEXPECTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ACCESS_DENIED ==
+ static_cast<NetworkCode>(net::ERR_ACCESS_DENIED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NOT_IMPLEMENTED ==
+ static_cast<NetworkCode>(net::ERR_NOT_IMPLEMENTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INSUFFICIENT_RESOURCES ==
+ static_cast<NetworkCode>(net::ERR_INSUFFICIENT_RESOURCES),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_OUT_OF_MEMORY ==
+ static_cast<NetworkCode>(net::ERR_OUT_OF_MEMORY),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UPLOAD_FILE_CHANGED ==
+ static_cast<NetworkCode>(net::ERR_UPLOAD_FILE_CHANGED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SOCKET_NOT_CONNECTED ==
+ static_cast<NetworkCode>(net::ERR_SOCKET_NOT_CONNECTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FILE_EXISTS ==
+ static_cast<NetworkCode>(net::ERR_FILE_EXISTS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FILE_PATH_TOO_LONG ==
+ static_cast<NetworkCode>(net::ERR_FILE_PATH_TOO_LONG),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FILE_NO_SPACE ==
+ static_cast<NetworkCode>(net::ERR_FILE_NO_SPACE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FILE_VIRUS_INFECTED ==
+ static_cast<NetworkCode>(net::ERR_FILE_VIRUS_INFECTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_BLOCKED_BY_CLIENT ==
+ static_cast<NetworkCode>(net::ERR_BLOCKED_BY_CLIENT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NETWORK_CHANGED ==
+ static_cast<NetworkCode>(net::ERR_NETWORK_CHANGED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_BLOCKED_BY_ADMINISTRATOR ==
+ static_cast<NetworkCode>(net::ERR_BLOCKED_BY_ADMINISTRATOR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SOCKET_IS_CONNECTED ==
+ static_cast<NetworkCode>(net::ERR_SOCKET_IS_CONNECTED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_BLOCKED_ENROLLMENT_CHECK_PENDING ==
+ static_cast<NetworkCode>(net::ERR_BLOCKED_ENROLLMENT_CHECK_PENDING),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_UPLOAD_STREAM_REWIND_NOT_SUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONNECTION_CLOSED ==
+ static_cast<NetworkCode>(net::ERR_CONNECTION_CLOSED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONNECTION_RESET ==
+ static_cast<NetworkCode>(net::ERR_CONNECTION_RESET),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONNECTION_REFUSED ==
+ static_cast<NetworkCode>(net::ERR_CONNECTION_REFUSED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONNECTION_ABORTED ==
+ static_cast<NetworkCode>(net::ERR_CONNECTION_ABORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONNECTION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_CONNECTION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NAME_NOT_RESOLVED ==
+ static_cast<NetworkCode>(net::ERR_NAME_NOT_RESOLVED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INTERNET_DISCONNECTED ==
+ static_cast<NetworkCode>(net::ERR_INTERNET_DISCONNECTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_PROTOCOL_ERROR ==
+ static_cast<NetworkCode>(net::ERR_SSL_PROTOCOL_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ADDRESS_INVALID ==
+ static_cast<NetworkCode>(net::ERR_ADDRESS_INVALID),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ADDRESS_UNREACHABLE ==
+ static_cast<NetworkCode>(net::ERR_ADDRESS_UNREACHABLE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_CLIENT_AUTH_CERT_NEEDED ==
+ static_cast<NetworkCode>(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_TUNNEL_CONNECTION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_TUNNEL_CONNECTION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NO_SSL_VERSIONS_ENABLED ==
+ static_cast<NetworkCode>(net::ERR_NO_SSL_VERSIONS_ENABLED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_VERSION_OR_CIPHER_MISMATCH ==
+ static_cast<NetworkCode>(net::ERR_SSL_VERSION_OR_CIPHER_MISMATCH),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_RENEGOTIATION_REQUESTED ==
+ static_cast<NetworkCode>(net::ERR_SSL_RENEGOTIATION_REQUESTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PROXY_AUTH_UNSUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_PROXY_AUTH_UNSUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CERT_ERROR_IN_SSL_RENEGOTIATION ==
+ static_cast<NetworkCode>(net::ERR_CERT_ERROR_IN_SSL_RENEGOTIATION),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_BAD_SSL_CLIENT_AUTH_CERT ==
+ static_cast<NetworkCode>(net::ERR_BAD_SSL_CLIENT_AUTH_CERT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONNECTION_TIMED_OUT ==
+ static_cast<NetworkCode>(net::ERR_CONNECTION_TIMED_OUT),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_HOST_RESOLVER_QUEUE_TOO_LARGE ==
+ static_cast<NetworkCode>(net::ERR_HOST_RESOLVER_QUEUE_TOO_LARGE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SOCKS_CONNECTION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_SOCKS_CONNECTION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SOCKS_CONNECTION_HOST_UNREACHABLE ==
+ static_cast<NetworkCode>(net::ERR_SOCKS_CONNECTION_HOST_UNREACHABLE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NPN_NEGOTIATION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_NPN_NEGOTIATION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_NO_RENEGOTIATION ==
+ static_cast<NetworkCode>(net::ERR_SSL_NO_RENEGOTIATION),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_WINSOCK_UNEXPECTED_WRITTEN_BYTES ==
+ static_cast<NetworkCode>(net::ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_DECOMPRESSION_FAILURE_ALERT ==
+ static_cast<NetworkCode>(net::ERR_SSL_DECOMPRESSION_FAILURE_ALERT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_BAD_RECORD_MAC_ALERT ==
+ static_cast<NetworkCode>(net::ERR_SSL_BAD_RECORD_MAC_ALERT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PROXY_AUTH_REQUESTED ==
+ static_cast<NetworkCode>(net::ERR_PROXY_AUTH_REQUESTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_UNSAFE_NEGOTIATION ==
+ static_cast<NetworkCode>(net::ERR_SSL_UNSAFE_NEGOTIATION),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY ==
+ static_cast<NetworkCode>(net::ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PROXY_CONNECTION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_PROXY_CONNECTION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_MANDATORY_PROXY_CONFIGURATION_FAILED ==
+ static_cast<NetworkCode>(
+ net::ERR_MANDATORY_PROXY_CONFIGURATION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PRECONNECT_MAX_SOCKET_LIMIT ==
+ static_cast<NetworkCode>(net::ERR_PRECONNECT_MAX_SOCKET_LIMIT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED ==
+ static_cast<NetworkCode>(
+ net::ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY ==
+ static_cast<NetworkCode>(
+ net::ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PROXY_CERTIFICATE_INVALID ==
+ static_cast<NetworkCode>(net::ERR_PROXY_CERTIFICATE_INVALID),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NAME_RESOLUTION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_NAME_RESOLUTION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NETWORK_ACCESS_DENIED ==
+ static_cast<NetworkCode>(net::ERR_NETWORK_ACCESS_DENIED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_TEMPORARILY_THROTTLED ==
+ static_cast<NetworkCode>(net::ERR_TEMPORARILY_THROTTLED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_HTTPS_PROXY_TUNNEL_RESPONSE ==
+ static_cast<NetworkCode>(net::ERR_HTTPS_PROXY_TUNNEL_RESPONSE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_CLIENT_AUTH_SIGNATURE_FAILED ==
+ static_cast<NetworkCode>(net::ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_MSG_TOO_BIG ==
+ static_cast<NetworkCode>(net::ERR_MSG_TOO_BIG),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SPDY_SESSION_ALREADY_EXISTS ==
+ static_cast<NetworkCode>(net::ERR_SPDY_SESSION_ALREADY_EXISTS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_WS_PROTOCOL_ERROR ==
+ static_cast<NetworkCode>(net::ERR_WS_PROTOCOL_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ADDRESS_IN_USE ==
+ static_cast<NetworkCode>(net::ERR_ADDRESS_IN_USE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_HANDSHAKE_NOT_COMPLETED ==
+ static_cast<NetworkCode>(net::ERR_SSL_HANDSHAKE_NOT_COMPLETED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_BAD_PEER_PUBLIC_KEY ==
+ static_cast<NetworkCode>(net::ERR_SSL_BAD_PEER_PUBLIC_KEY),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN ==
+ static_cast<NetworkCode>(net::ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ORIGIN_BOUND_CERT_GENERATION_TYPE_MISMATCH ==
+ static_cast<NetworkCode>(
+ net::ERR_ORIGIN_BOUND_CERT_GENERATION_TYPE_MISMATCH),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_DECRYPT_ERROR_ALERT ==
+ static_cast<NetworkCode>(net::ERR_SSL_DECRYPT_ERROR_ALERT),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_WS_THROTTLE_QUEUE_TOO_LARGE ==
+ static_cast<NetworkCode>(net::ERR_WS_THROTTLE_QUEUE_TOO_LARGE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_SERVER_CERT_CHANGED ==
+ static_cast<NetworkCode>(net::ERR_SSL_SERVER_CERT_CHANGED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_INAPPROPRIATE_FALLBACK ==
+ static_cast<NetworkCode>(net::ERR_SSL_INAPPROPRIATE_FALLBACK),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CT_NO_SCTS_VERIFIED_OK ==
+ static_cast<NetworkCode>(net::ERR_CT_NO_SCTS_VERIFIED_OK),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_UNRECOGNIZED_NAME_ALERT ==
+ static_cast<NetworkCode>(net::ERR_SSL_UNRECOGNIZED_NAME_ALERT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR ==
+ static_cast<NetworkCode>(
+ net::ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SOCKET_SET_SEND_BUFFER_SIZE_ERROR ==
+ static_cast<NetworkCode>(net::ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE ==
+ static_cast<NetworkCode>(
+ net::ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE ==
+ static_cast<NetworkCode>(
+ net::ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SSL_CLIENT_AUTH_CERT_BAD_FORMAT ==
+ static_cast<NetworkCode>(net::ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SSL_FALLBACK_BEYOND_MINIMUM_VERSION ==
+ static_cast<NetworkCode>(
+ net::ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_COMMON_NAME_INVALID ==
+ static_cast<NetworkCode>(net::ERR_CERT_COMMON_NAME_INVALID),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_DATE_INVALID ==
+ static_cast<NetworkCode>(net::ERR_CERT_DATE_INVALID),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_AUTHORITY_INVALID ==
+ static_cast<NetworkCode>(net::ERR_CERT_AUTHORITY_INVALID),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_CONTAINS_ERRORS ==
+ static_cast<NetworkCode>(net::ERR_CERT_CONTAINS_ERRORS),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CERT_NO_REVOCATION_MECHANISM ==
+ static_cast<NetworkCode>(net::ERR_CERT_NO_REVOCATION_MECHANISM),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CERT_UNABLE_TO_CHECK_REVOCATION ==
+ static_cast<NetworkCode>(net::ERR_CERT_UNABLE_TO_CHECK_REVOCATION),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_REVOKED ==
+ static_cast<NetworkCode>(net::ERR_CERT_REVOKED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_INVALID ==
+ static_cast<NetworkCode>(net::ERR_CERT_INVALID),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CERT_WEAK_SIGNATURE_ALGORITHM ==
+ static_cast<NetworkCode>(net::ERR_CERT_WEAK_SIGNATURE_ALGORITHM),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_NON_UNIQUE_NAME ==
+ static_cast<NetworkCode>(net::ERR_CERT_NON_UNIQUE_NAME),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_WEAK_KEY ==
+ static_cast<NetworkCode>(net::ERR_CERT_WEAK_KEY),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CERT_NAME_CONSTRAINT_VIOLATION ==
+ static_cast<NetworkCode>(net::ERR_CERT_NAME_CONSTRAINT_VIOLATION),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_VALIDITY_TOO_LONG ==
+ static_cast<NetworkCode>(net::ERR_CERT_VALIDITY_TOO_LONG),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CERT_END == static_cast<NetworkCode>(net::ERR_CERT_END),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_URL ==
+ static_cast<NetworkCode>(net::ERR_INVALID_URL),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DISALLOWED_URL_SCHEME ==
+ static_cast<NetworkCode>(net::ERR_DISALLOWED_URL_SCHEME),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNKNOWN_URL_SCHEME ==
+ static_cast<NetworkCode>(net::ERR_UNKNOWN_URL_SCHEME),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_TOO_MANY_REDIRECTS ==
+ static_cast<NetworkCode>(net::ERR_TOO_MANY_REDIRECTS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNSAFE_REDIRECT ==
+ static_cast<NetworkCode>(net::ERR_UNSAFE_REDIRECT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNSAFE_PORT ==
+ static_cast<NetworkCode>(net::ERR_UNSAFE_PORT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_RESPONSE ==
+ static_cast<NetworkCode>(net::ERR_INVALID_RESPONSE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_CHUNKED_ENCODING ==
+ static_cast<NetworkCode>(net::ERR_INVALID_CHUNKED_ENCODING),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_METHOD_NOT_SUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_METHOD_NOT_SUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNEXPECTED_PROXY_AUTH ==
+ static_cast<NetworkCode>(net::ERR_UNEXPECTED_PROXY_AUTH),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_EMPTY_RESPONSE ==
+ static_cast<NetworkCode>(net::ERR_EMPTY_RESPONSE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_RESPONSE_HEADERS_TOO_BIG ==
+ static_cast<NetworkCode>(net::ERR_RESPONSE_HEADERS_TOO_BIG),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PAC_STATUS_NOT_OK ==
+ static_cast<NetworkCode>(net::ERR_PAC_STATUS_NOT_OK),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PAC_SCRIPT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_PAC_SCRIPT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_REQUEST_RANGE_NOT_SATISFIABLE ==
+ static_cast<NetworkCode>(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_MALFORMED_IDENTITY ==
+ static_cast<NetworkCode>(net::ERR_MALFORMED_IDENTITY),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONTENT_DECODING_FAILED ==
+ static_cast<NetworkCode>(net::ERR_CONTENT_DECODING_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NETWORK_IO_SUSPENDED ==
+ static_cast<NetworkCode>(net::ERR_NETWORK_IO_SUSPENDED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SYN_REPLY_NOT_RECEIVED ==
+ static_cast<NetworkCode>(net::ERR_SYN_REPLY_NOT_RECEIVED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_ENCODING_CONVERSION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_ENCODING_CONVERSION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT ==
+ static_cast<NetworkCode>(
+ net::ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_SPDY_STREAM ==
+ static_cast<NetworkCode>(net::ERR_INVALID_SPDY_STREAM),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NO_SUPPORTED_PROXIES ==
+ static_cast<NetworkCode>(net::ERR_NO_SUPPORTED_PROXIES),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SPDY_PROTOCOL_ERROR ==
+ static_cast<NetworkCode>(net::ERR_SPDY_PROTOCOL_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INVALID_AUTH_CREDENTIALS ==
+ static_cast<NetworkCode>(net::ERR_INVALID_AUTH_CREDENTIALS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNSUPPORTED_AUTH_SCHEME ==
+ static_cast<NetworkCode>(net::ERR_UNSUPPORTED_AUTH_SCHEME),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_ENCODING_DETECTION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_ENCODING_DETECTION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_MISSING_AUTH_CREDENTIALS ==
+ static_cast<NetworkCode>(net::ERR_MISSING_AUTH_CREDENTIALS),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_UNEXPECTED_SECURITY_LIBRARY_STATUS ==
+ static_cast<NetworkCode>(net::ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_MISCONFIGURED_AUTH_ENVIRONMENT ==
+ static_cast<NetworkCode>(net::ERR_MISCONFIGURED_AUTH_ENVIRONMENT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_UNDOCUMENTED_SECURITY_LIBRARY_STATUS ==
+ static_cast<NetworkCode>(
+ net::ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_RESPONSE_BODY_TOO_BIG_TO_DRAIN ==
+ static_cast<NetworkCode>(net::ERR_RESPONSE_BODY_TOO_BIG_TO_DRAIN),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH ==
+ static_cast<NetworkCode>(
+ net::ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INCOMPLETE_SPDY_HEADERS ==
+ static_cast<NetworkCode>(net::ERR_INCOMPLETE_SPDY_HEADERS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PAC_NOT_IN_DHCP ==
+ static_cast<NetworkCode>(net::ERR_PAC_NOT_IN_DHCP),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION ==
+ static_cast<NetworkCode>(
+ net::ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_RESPONSE_HEADERS_MULTIPLE_LOCATION ==
+ static_cast<NetworkCode>(net::ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SPDY_SERVER_REFUSED_STREAM ==
+ static_cast<NetworkCode>(net::ERR_SPDY_SERVER_REFUSED_STREAM),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SPDY_PING_FAILED ==
+ static_cast<NetworkCode>(net::ERR_SPDY_PING_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CONTENT_LENGTH_MISMATCH ==
+ static_cast<NetworkCode>(net::ERR_CONTENT_LENGTH_MISMATCH),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_INCOMPLETE_CHUNKED_ENCODING ==
+ static_cast<NetworkCode>(net::ERR_INCOMPLETE_CHUNKED_ENCODING),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_QUIC_PROTOCOL_ERROR ==
+ static_cast<NetworkCode>(net::ERR_QUIC_PROTOCOL_ERROR),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_RESPONSE_HEADERS_TRUNCATED ==
+ static_cast<NetworkCode>(net::ERR_RESPONSE_HEADERS_TRUNCATED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_QUIC_HANDSHAKE_FAILED ==
+ static_cast<NetworkCode>(net::ERR_QUIC_HANDSHAKE_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC ==
+ static_cast<NetworkCode>(
+ net::ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SPDY_INADEQUATE_TRANSPORT_SECURITY ==
+ static_cast<NetworkCode>(net::ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SPDY_FLOW_CONTROL_ERROR ==
+ static_cast<NetworkCode>(net::ERR_SPDY_FLOW_CONTROL_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SPDY_FRAME_SIZE_ERROR ==
+ static_cast<NetworkCode>(net::ERR_SPDY_FRAME_SIZE_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_SPDY_COMPRESSION_ERROR ==
+ static_cast<NetworkCode>(net::ERR_SPDY_COMPRESSION_ERROR),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION ==
+ static_cast<NetworkCode>(
+ net::ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_HTTP_1_1_REQUIRED ==
+ static_cast<NetworkCode>(net::ERR_HTTP_1_1_REQUIRED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PROXY_HTTP_1_1_REQUIRED ==
+ static_cast<NetworkCode>(net::ERR_PROXY_HTTP_1_1_REQUIRED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CACHE_MISS == static_cast<NetworkCode>(net::ERR_CACHE_MISS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CACHE_READ_FAILURE ==
+ static_cast<NetworkCode>(net::ERR_CACHE_READ_FAILURE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CACHE_WRITE_FAILURE ==
+ static_cast<NetworkCode>(net::ERR_CACHE_WRITE_FAILURE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CACHE_OPERATION_NOT_SUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_CACHE_OPERATION_NOT_SUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CACHE_OPEN_FAILURE ==
+ static_cast<NetworkCode>(net::ERR_CACHE_OPEN_FAILURE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CACHE_CREATE_FAILURE ==
+ static_cast<NetworkCode>(net::ERR_CACHE_CREATE_FAILURE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CACHE_RACE == static_cast<NetworkCode>(net::ERR_CACHE_RACE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_CACHE_CHECKSUM_READ_FAILURE ==
+ static_cast<NetworkCode>(net::ERR_CACHE_CHECKSUM_READ_FAILURE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CACHE_CHECKSUM_MISMATCH ==
+ static_cast<NetworkCode>(net::ERR_CACHE_CHECKSUM_MISMATCH),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CACHE_LOCK_TIMEOUT ==
+ static_cast<NetworkCode>(net::ERR_CACHE_LOCK_TIMEOUT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_INSECURE_RESPONSE ==
+ static_cast<NetworkCode>(net::ERR_INSECURE_RESPONSE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_NO_PRIVATE_KEY_FOR_CERT ==
+ static_cast<NetworkCode>(net::ERR_NO_PRIVATE_KEY_FOR_CERT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ADD_USER_CERT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_ADD_USER_CERT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_FTP_FAILED == static_cast<NetworkCode>(net::ERR_FTP_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FTP_SERVICE_UNAVAILABLE ==
+ static_cast<NetworkCode>(net::ERR_FTP_SERVICE_UNAVAILABLE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FTP_TRANSFER_ABORTED ==
+ static_cast<NetworkCode>(net::ERR_FTP_TRANSFER_ABORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FTP_FILE_BUSY ==
+ static_cast<NetworkCode>(net::ERR_FTP_FILE_BUSY),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FTP_SYNTAX_ERROR ==
+ static_cast<NetworkCode>(net::ERR_FTP_SYNTAX_ERROR),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_FTP_COMMAND_NOT_SUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_FTP_COMMAND_NOT_SUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_FTP_BAD_COMMAND_SEQUENCE ==
+ static_cast<NetworkCode>(net::ERR_FTP_BAD_COMMAND_SEQUENCE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PKCS12_IMPORT_BAD_PASSWORD ==
+ static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_BAD_PASSWORD),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_PKCS12_IMPORT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_IMPORT_CA_CERT_NOT_CA ==
+ static_cast<NetworkCode>(net::ERR_IMPORT_CA_CERT_NOT_CA),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_IMPORT_CERT_ALREADY_EXISTS ==
+ static_cast<NetworkCode>(net::ERR_IMPORT_CERT_ALREADY_EXISTS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_IMPORT_CA_CERT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_IMPORT_CA_CERT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_IMPORT_SERVER_CERT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_IMPORT_SERVER_CERT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PKCS12_IMPORT_INVALID_MAC ==
+ static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_INVALID_MAC),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PKCS12_IMPORT_INVALID_FILE ==
+ static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_INVALID_FILE),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PKCS12_IMPORT_UNSUPPORTED ==
+ static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_UNSUPPORTED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_KEY_GENERATION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_KEY_GENERATION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_ORIGIN_BOUND_CERT_GENERATION_FAILED ==
+ static_cast<NetworkCode>(
+ net::ERR_ORIGIN_BOUND_CERT_GENERATION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_PRIVATE_KEY_EXPORT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_PRIVATE_KEY_EXPORT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(
+ NETWORK_CODE_SELF_SIGNED_CERT_GENERATION_FAILED ==
+ static_cast<NetworkCode>(net::ERR_SELF_SIGNED_CERT_GENERATION_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CERT_DATABASE_CHANGED ==
+ static_cast<NetworkCode>(net::ERR_CERT_DATABASE_CHANGED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_CHANNEL_ID_IMPORT_FAILED ==
+ static_cast<NetworkCode>(net::ERR_CHANNEL_ID_IMPORT_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_MALFORMED_RESPONSE ==
+ static_cast<NetworkCode>(net::ERR_DNS_MALFORMED_RESPONSE),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_SERVER_REQUIRES_TCP ==
+ static_cast<NetworkCode>(net::ERR_DNS_SERVER_REQUIRES_TCP),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_SERVER_FAILED ==
+ static_cast<NetworkCode>(net::ERR_DNS_SERVER_FAILED),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_TIMED_OUT ==
+ static_cast<NetworkCode>(net::ERR_DNS_TIMED_OUT),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_CACHE_MISS ==
+ static_cast<NetworkCode>(net::ERR_DNS_CACHE_MISS),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_SEARCH_EMPTY ==
+ static_cast<NetworkCode>(net::ERR_DNS_SEARCH_EMPTY),
+ "Network code enum mismatch.");
+ static_assert(NETWORK_CODE_DNS_SORT_ERROR ==
+ static_cast<NetworkCode>(net::ERR_DNS_SORT_ERROR),
+ "Network code enum mismatch.");
+
NetworkErrorPtr error = NetworkError::New();
- error->code = error_code;
+ error->code = static_cast<NetworkCode>(error_code);
if (error_code <= 0)
error->description = net::ErrorToString(error_code);
return error.Pass();
« no previous file with comments | « mojo/services/html_viewer/weburlloader_impl.cc ('k') | mojo/services/network/public/interfaces/network_error.mojom » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698