mojo/services/network/net_adapters.cc - Issue 933973002: Return errors from the Mojo network service using an enum.

Side by Side 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 unified diff | Download patch

OLD	NEW
1 // Copyright 2014 The Chromium Authors. All rights reserved.	1 // Copyright 2014 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be	2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.	3 // found in the LICENSE file.

4	4

5 #include "mojo/services/network/net_adapters.h"	5 #include "mojo/services/network/net_adapters.h"

6	6

7 #include "net/base/net_errors.h"	7 #include "net/base/net_errors.h"

8	8

9 namespace mojo {	9 namespace mojo {

10	10

(...skipping 90 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
101 : net::WrappedIOBuffer(pending_buffer->buffer()),	101 : net::WrappedIOBuffer(pending_buffer->buffer()),

102 pending_buffer_(pending_buffer) {	102 pending_buffer_(pending_buffer) {

103 }	103 }

104	104

105 MojoToNetIOBuffer::~MojoToNetIOBuffer() {	105 MojoToNetIOBuffer::~MojoToNetIOBuffer() {

106 }	106 }

107	107

108 // -----------------------------------------------------------------------------	108 // -----------------------------------------------------------------------------

109	109

110 NetworkErrorPtr MakeNetworkError(int error_code) {	110 NetworkErrorPtr MakeNetworkError(int error_code) {

	111 // The NetworkCode enum values defined in network_error.mojom should match net

	112 // error codes from net/net_errors.h.
	qsr 2015/02/19 14:27:00 Could you use the include + macro mechanism to do Could you use the include + macro mechanism to do this? ppi 2015/02/19 15:36:09 Done. As discussed in person, it's not clear if ty Show quoted text On 2015/02/19 14:27:00, qsr wrote: > Could you use the include + macro mechanism to do this? Done. As discussed in person, it's not clear if tying our mojom to the net_error_list is optimal. Sent an email to mojo-dev and net-dev to see what people think.
	113 static_assert(NETWORK_CODE_OK == static_cast<NetworkCode>(net::OK),

	114 "Network code enum mismatch.");

	115 static_assert(

	116 NETWORK_CODE_IO_PENDING == static_cast<NetworkCode>(net::ERR_IO_PENDING),

	117 "Network code enum mismatch.");

	118 static_assert(

	119 NETWORK_CODE_FAILED == static_cast<NetworkCode>(net::ERR_FAILED),

	120 "Network code enum mismatch.");

	121 static_assert(

	122 NETWORK_CODE_ABORTED == static_cast<NetworkCode>(net::ERR_ABORTED),

	123 "Network code enum mismatch.");

	124 static_assert(NETWORK_CODE_INVALID_ARGUMENT ==

	125 static_cast<NetworkCode>(net::ERR_INVALID_ARGUMENT),

	126 "Network code enum mismatch.");

	127 static_assert(NETWORK_CODE_INVALID_HANDLE ==

	128 static_cast<NetworkCode>(net::ERR_INVALID_HANDLE),

	129 "Network code enum mismatch.");

	130 static_assert(NETWORK_CODE_FILE_NOT_FOUND ==

	131 static_cast<NetworkCode>(net::ERR_FILE_NOT_FOUND),

	132 "Network code enum mismatch.");

	133 static_assert(

	134 NETWORK_CODE_TIMED_OUT == static_cast<NetworkCode>(net::ERR_TIMED_OUT),

	135 "Network code enum mismatch.");

	136 static_assert(NETWORK_CODE_FILE_TOO_BIG ==

	137 static_cast<NetworkCode>(net::ERR_FILE_TOO_BIG),

	138 "Network code enum mismatch.");

	139 static_assert(

	140 NETWORK_CODE_UNEXPECTED == static_cast<NetworkCode>(net::ERR_UNEXPECTED),

	141 "Network code enum mismatch.");

	142 static_assert(NETWORK_CODE_ACCESS_DENIED ==

	143 static_cast<NetworkCode>(net::ERR_ACCESS_DENIED),

	144 "Network code enum mismatch.");

	145 static_assert(NETWORK_CODE_NOT_IMPLEMENTED ==

	146 static_cast<NetworkCode>(net::ERR_NOT_IMPLEMENTED),

	147 "Network code enum mismatch.");

	148 static_assert(NETWORK_CODE_INSUFFICIENT_RESOURCES ==

	149 static_cast<NetworkCode>(net::ERR_INSUFFICIENT_RESOURCES),

	150 "Network code enum mismatch.");

	151 static_assert(NETWORK_CODE_OUT_OF_MEMORY ==

	152 static_cast<NetworkCode>(net::ERR_OUT_OF_MEMORY),

	153 "Network code enum mismatch.");

	154 static_assert(NETWORK_CODE_UPLOAD_FILE_CHANGED ==

	155 static_cast<NetworkCode>(net::ERR_UPLOAD_FILE_CHANGED),

	156 "Network code enum mismatch.");

	157 static_assert(NETWORK_CODE_SOCKET_NOT_CONNECTED ==

	158 static_cast<NetworkCode>(net::ERR_SOCKET_NOT_CONNECTED),

	159 "Network code enum mismatch.");

	160 static_assert(NETWORK_CODE_FILE_EXISTS ==

	161 static_cast<NetworkCode>(net::ERR_FILE_EXISTS),

	162 "Network code enum mismatch.");

	163 static_assert(NETWORK_CODE_FILE_PATH_TOO_LONG ==

	164 static_cast<NetworkCode>(net::ERR_FILE_PATH_TOO_LONG),

	165 "Network code enum mismatch.");

	166 static_assert(NETWORK_CODE_FILE_NO_SPACE ==

	167 static_cast<NetworkCode>(net::ERR_FILE_NO_SPACE),

	168 "Network code enum mismatch.");

	169 static_assert(NETWORK_CODE_FILE_VIRUS_INFECTED ==

	170 static_cast<NetworkCode>(net::ERR_FILE_VIRUS_INFECTED),

	171 "Network code enum mismatch.");

	172 static_assert(NETWORK_CODE_BLOCKED_BY_CLIENT ==

	173 static_cast<NetworkCode>(net::ERR_BLOCKED_BY_CLIENT),

	174 "Network code enum mismatch.");

	175 static_assert(NETWORK_CODE_NETWORK_CHANGED ==

	176 static_cast<NetworkCode>(net::ERR_NETWORK_CHANGED),

	177 "Network code enum mismatch.");

	178 static_assert(NETWORK_CODE_BLOCKED_BY_ADMINISTRATOR ==

	179 static_cast<NetworkCode>(net::ERR_BLOCKED_BY_ADMINISTRATOR),

	180 "Network code enum mismatch.");

	181 static_assert(NETWORK_CODE_SOCKET_IS_CONNECTED ==

	182 static_cast<NetworkCode>(net::ERR_SOCKET_IS_CONNECTED),

	183 "Network code enum mismatch.");

	184 static_assert(

	185 NETWORK_CODE_BLOCKED_ENROLLMENT_CHECK_PENDING ==

	186 static_cast<NetworkCode>(net::ERR_BLOCKED_ENROLLMENT_CHECK_PENDING),

	187 "Network code enum mismatch.");

	188 static_assert(

	189 NETWORK_CODE_UPLOAD_STREAM_REWIND_NOT_SUPPORTED ==

	190 static_cast<NetworkCode>(net::ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED),

	191 "Network code enum mismatch.");

	192 static_assert(NETWORK_CODE_CONNECTION_CLOSED ==

	193 static_cast<NetworkCode>(net::ERR_CONNECTION_CLOSED),

	194 "Network code enum mismatch.");

	195 static_assert(NETWORK_CODE_CONNECTION_RESET ==

	196 static_cast<NetworkCode>(net::ERR_CONNECTION_RESET),

	197 "Network code enum mismatch.");

	198 static_assert(NETWORK_CODE_CONNECTION_REFUSED ==

	199 static_cast<NetworkCode>(net::ERR_CONNECTION_REFUSED),

	200 "Network code enum mismatch.");

	201 static_assert(NETWORK_CODE_CONNECTION_ABORTED ==

	202 static_cast<NetworkCode>(net::ERR_CONNECTION_ABORTED),

	203 "Network code enum mismatch.");

	204 static_assert(NETWORK_CODE_CONNECTION_FAILED ==

	205 static_cast<NetworkCode>(net::ERR_CONNECTION_FAILED),

	206 "Network code enum mismatch.");

	207 static_assert(NETWORK_CODE_NAME_NOT_RESOLVED ==

	208 static_cast<NetworkCode>(net::ERR_NAME_NOT_RESOLVED),

	209 "Network code enum mismatch.");

	210 static_assert(NETWORK_CODE_INTERNET_DISCONNECTED ==

	211 static_cast<NetworkCode>(net::ERR_INTERNET_DISCONNECTED),

	212 "Network code enum mismatch.");

	213 static_assert(NETWORK_CODE_SSL_PROTOCOL_ERROR ==

	214 static_cast<NetworkCode>(net::ERR_SSL_PROTOCOL_ERROR),

	215 "Network code enum mismatch.");

	216 static_assert(NETWORK_CODE_ADDRESS_INVALID ==

	217 static_cast<NetworkCode>(net::ERR_ADDRESS_INVALID),

	218 "Network code enum mismatch.");

	219 static_assert(NETWORK_CODE_ADDRESS_UNREACHABLE ==

	220 static_cast<NetworkCode>(net::ERR_ADDRESS_UNREACHABLE),

	221 "Network code enum mismatch.");

	222 static_assert(

	223 NETWORK_CODE_SSL_CLIENT_AUTH_CERT_NEEDED ==

	224 static_cast<NetworkCode>(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED),

	225 "Network code enum mismatch.");

	226 static_assert(NETWORK_CODE_TUNNEL_CONNECTION_FAILED ==

	227 static_cast<NetworkCode>(net::ERR_TUNNEL_CONNECTION_FAILED),

	228 "Network code enum mismatch.");

	229 static_assert(NETWORK_CODE_NO_SSL_VERSIONS_ENABLED ==

	230 static_cast<NetworkCode>(net::ERR_NO_SSL_VERSIONS_ENABLED),

	231 "Network code enum mismatch.");

	232 static_assert(

	233 NETWORK_CODE_SSL_VERSION_OR_CIPHER_MISMATCH ==

	234 static_cast<NetworkCode>(net::ERR_SSL_VERSION_OR_CIPHER_MISMATCH),

	235 "Network code enum mismatch.");

	236 static_assert(

	237 NETWORK_CODE_SSL_RENEGOTIATION_REQUESTED ==

	238 static_cast<NetworkCode>(net::ERR_SSL_RENEGOTIATION_REQUESTED),

	239 "Network code enum mismatch.");

	240 static_assert(NETWORK_CODE_PROXY_AUTH_UNSUPPORTED ==

	241 static_cast<NetworkCode>(net::ERR_PROXY_AUTH_UNSUPPORTED),

	242 "Network code enum mismatch.");

	243 static_assert(

	244 NETWORK_CODE_CERT_ERROR_IN_SSL_RENEGOTIATION ==

	245 static_cast<NetworkCode>(net::ERR_CERT_ERROR_IN_SSL_RENEGOTIATION),

	246 "Network code enum mismatch.");

	247 static_assert(NETWORK_CODE_BAD_SSL_CLIENT_AUTH_CERT ==

	248 static_cast<NetworkCode>(net::ERR_BAD_SSL_CLIENT_AUTH_CERT),

	249 "Network code enum mismatch.");

	250 static_assert(NETWORK_CODE_CONNECTION_TIMED_OUT ==

	251 static_cast<NetworkCode>(net::ERR_CONNECTION_TIMED_OUT),

	252 "Network code enum mismatch.");

	253 static_assert(

	254 NETWORK_CODE_HOST_RESOLVER_QUEUE_TOO_LARGE ==

	255 static_cast<NetworkCode>(net::ERR_HOST_RESOLVER_QUEUE_TOO_LARGE),

	256 "Network code enum mismatch.");

	257 static_assert(NETWORK_CODE_SOCKS_CONNECTION_FAILED ==

	258 static_cast<NetworkCode>(net::ERR_SOCKS_CONNECTION_FAILED),

	259 "Network code enum mismatch.");

	260 static_assert(

	261 NETWORK_CODE_SOCKS_CONNECTION_HOST_UNREACHABLE ==

	262 static_cast<NetworkCode>(net::ERR_SOCKS_CONNECTION_HOST_UNREACHABLE),

	263 "Network code enum mismatch.");

	264 static_assert(NETWORK_CODE_NPN_NEGOTIATION_FAILED ==

	265 static_cast<NetworkCode>(net::ERR_NPN_NEGOTIATION_FAILED),

	266 "Network code enum mismatch.");

	267 static_assert(NETWORK_CODE_SSL_NO_RENEGOTIATION ==

	268 static_cast<NetworkCode>(net::ERR_SSL_NO_RENEGOTIATION),

	269 "Network code enum mismatch.");

	270 static_assert(

	271 NETWORK_CODE_WINSOCK_UNEXPECTED_WRITTEN_BYTES ==

	272 static_cast<NetworkCode>(net::ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES),

	273 "Network code enum mismatch.");

	274 static_assert(

	275 NETWORK_CODE_SSL_DECOMPRESSION_FAILURE_ALERT ==

	276 static_cast<NetworkCode>(net::ERR_SSL_DECOMPRESSION_FAILURE_ALERT),

	277 "Network code enum mismatch.");

	278 static_assert(NETWORK_CODE_SSL_BAD_RECORD_MAC_ALERT ==

	279 static_cast<NetworkCode>(net::ERR_SSL_BAD_RECORD_MAC_ALERT),

	280 "Network code enum mismatch.");

	281 static_assert(NETWORK_CODE_PROXY_AUTH_REQUESTED ==

	282 static_cast<NetworkCode>(net::ERR_PROXY_AUTH_REQUESTED),

	283 "Network code enum mismatch.");

	284 static_assert(NETWORK_CODE_SSL_UNSAFE_NEGOTIATION ==

	285 static_cast<NetworkCode>(net::ERR_SSL_UNSAFE_NEGOTIATION),

	286 "Network code enum mismatch.");

	287 static_assert(

	288 NETWORK_CODE_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY ==

	289 static_cast<NetworkCode>(net::ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY),

	290 "Network code enum mismatch.");

	291 static_assert(NETWORK_CODE_PROXY_CONNECTION_FAILED ==

	292 static_cast<NetworkCode>(net::ERR_PROXY_CONNECTION_FAILED),

	293 "Network code enum mismatch.");

	294 static_assert(NETWORK_CODE_MANDATORY_PROXY_CONFIGURATION_FAILED ==

	295 static_cast<NetworkCode>(

	296 net::ERR_MANDATORY_PROXY_CONFIGURATION_FAILED),

	297 "Network code enum mismatch.");

	298 static_assert(

	299 NETWORK_CODE_PRECONNECT_MAX_SOCKET_LIMIT ==

	300 static_cast<NetworkCode>(net::ERR_PRECONNECT_MAX_SOCKET_LIMIT),

	301 "Network code enum mismatch.");

	302 static_assert(NETWORK_CODE_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED ==

	303 static_cast<NetworkCode>(

	304 net::ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED),

	305 "Network code enum mismatch.");

	306 static_assert(NETWORK_CODE_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY ==

	307 static_cast<NetworkCode>(

	308 net::ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY),

	309 "Network code enum mismatch.");

	310 static_assert(

	311 NETWORK_CODE_PROXY_CERTIFICATE_INVALID ==

	312 static_cast<NetworkCode>(net::ERR_PROXY_CERTIFICATE_INVALID),

	313 "Network code enum mismatch.");

	314 static_assert(NETWORK_CODE_NAME_RESOLUTION_FAILED ==

	315 static_cast<NetworkCode>(net::ERR_NAME_RESOLUTION_FAILED),

	316 "Network code enum mismatch.");

	317 static_assert(NETWORK_CODE_NETWORK_ACCESS_DENIED ==

	318 static_cast<NetworkCode>(net::ERR_NETWORK_ACCESS_DENIED),

	319 "Network code enum mismatch.");

	320 static_assert(NETWORK_CODE_TEMPORARILY_THROTTLED ==

	321 static_cast<NetworkCode>(net::ERR_TEMPORARILY_THROTTLED),

	322 "Network code enum mismatch.");

	323 static_assert(

	324 NETWORK_CODE_HTTPS_PROXY_TUNNEL_RESPONSE ==

	325 static_cast<NetworkCode>(net::ERR_HTTPS_PROXY_TUNNEL_RESPONSE),

	326 "Network code enum mismatch.");

	327 static_assert(

	328 NETWORK_CODE_SSL_CLIENT_AUTH_SIGNATURE_FAILED ==

	329 static_cast<NetworkCode>(net::ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED),

	330 "Network code enum mismatch.");

	331 static_assert(NETWORK_CODE_MSG_TOO_BIG ==

	332 static_cast<NetworkCode>(net::ERR_MSG_TOO_BIG),

	333 "Network code enum mismatch.");

	334 static_assert(

	335 NETWORK_CODE_SPDY_SESSION_ALREADY_EXISTS ==

	336 static_cast<NetworkCode>(net::ERR_SPDY_SESSION_ALREADY_EXISTS),

	337 "Network code enum mismatch.");

	338 static_assert(NETWORK_CODE_WS_PROTOCOL_ERROR ==

	339 static_cast<NetworkCode>(net::ERR_WS_PROTOCOL_ERROR),

	340 "Network code enum mismatch.");

	341 static_assert(NETWORK_CODE_ADDRESS_IN_USE ==

	342 static_cast<NetworkCode>(net::ERR_ADDRESS_IN_USE),

	343 "Network code enum mismatch.");

	344 static_assert(

	345 NETWORK_CODE_SSL_HANDSHAKE_NOT_COMPLETED ==

	346 static_cast<NetworkCode>(net::ERR_SSL_HANDSHAKE_NOT_COMPLETED),

	347 "Network code enum mismatch.");

	348 static_assert(NETWORK_CODE_SSL_BAD_PEER_PUBLIC_KEY ==

	349 static_cast<NetworkCode>(net::ERR_SSL_BAD_PEER_PUBLIC_KEY),

	350 "Network code enum mismatch.");

	351 static_assert(

	352 NETWORK_CODE_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN ==

	353 static_cast<NetworkCode>(net::ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN),

	354 "Network code enum mismatch.");

	355 static_assert(

	356 NETWORK_CODE_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED ==

	357 static_cast<NetworkCode>(net::ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED),

	358 "Network code enum mismatch.");

	359 static_assert(NETWORK_CODE_ORIGIN_BOUND_CERT_GENERATION_TYPE_MISMATCH ==

	360 static_cast<NetworkCode>(

	361 net::ERR_ORIGIN_BOUND_CERT_GENERATION_TYPE_MISMATCH),

	362 "Network code enum mismatch.");

	363 static_assert(NETWORK_CODE_SSL_DECRYPT_ERROR_ALERT ==

	364 static_cast<NetworkCode>(net::ERR_SSL_DECRYPT_ERROR_ALERT),

	365 "Network code enum mismatch.");

	366 static_assert(

	367 NETWORK_CODE_WS_THROTTLE_QUEUE_TOO_LARGE ==

	368 static_cast<NetworkCode>(net::ERR_WS_THROTTLE_QUEUE_TOO_LARGE),

	369 "Network code enum mismatch.");

	370 static_assert(NETWORK_CODE_SSL_SERVER_CERT_CHANGED ==

	371 static_cast<NetworkCode>(net::ERR_SSL_SERVER_CERT_CHANGED),

	372 "Network code enum mismatch.");

	373 static_assert(

	374 NETWORK_CODE_SSL_INAPPROPRIATE_FALLBACK ==

	375 static_cast<NetworkCode>(net::ERR_SSL_INAPPROPRIATE_FALLBACK),

	376 "Network code enum mismatch.");

	377 static_assert(NETWORK_CODE_CT_NO_SCTS_VERIFIED_OK ==

	378 static_cast<NetworkCode>(net::ERR_CT_NO_SCTS_VERIFIED_OK),

	379 "Network code enum mismatch.");

	380 static_assert(

	381 NETWORK_CODE_SSL_UNRECOGNIZED_NAME_ALERT ==

	382 static_cast<NetworkCode>(net::ERR_SSL_UNRECOGNIZED_NAME_ALERT),

	383 "Network code enum mismatch.");

	384 static_assert(NETWORK_CODE_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR ==

	385 static_cast<NetworkCode>(

	386 net::ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR),

	387 "Network code enum mismatch.");

	388 static_assert(

	389 NETWORK_CODE_SOCKET_SET_SEND_BUFFER_SIZE_ERROR ==

	390 static_cast<NetworkCode>(net::ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR),

	391 "Network code enum mismatch.");

	392 static_assert(NETWORK_CODE_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE ==

	393 static_cast<NetworkCode>(

	394 net::ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE),

	395 "Network code enum mismatch.");

	396 static_assert(NETWORK_CODE_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE ==

	397 static_cast<NetworkCode>(

	398 net::ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE),

	399 "Network code enum mismatch.");

	400 static_assert(

	401 NETWORK_CODE_SSL_CLIENT_AUTH_CERT_BAD_FORMAT ==

	402 static_cast<NetworkCode>(net::ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT),

	403 "Network code enum mismatch.");

	404 static_assert(NETWORK_CODE_SSL_FALLBACK_BEYOND_MINIMUM_VERSION ==

	405 static_cast<NetworkCode>(

	406 net::ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION),

	407 "Network code enum mismatch.");

	408 static_assert(NETWORK_CODE_CERT_COMMON_NAME_INVALID ==

	409 static_cast<NetworkCode>(net::ERR_CERT_COMMON_NAME_INVALID),

	410 "Network code enum mismatch.");

	411 static_assert(NETWORK_CODE_CERT_DATE_INVALID ==

	412 static_cast<NetworkCode>(net::ERR_CERT_DATE_INVALID),

	413 "Network code enum mismatch.");

	414 static_assert(NETWORK_CODE_CERT_AUTHORITY_INVALID ==

	415 static_cast<NetworkCode>(net::ERR_CERT_AUTHORITY_INVALID),

	416 "Network code enum mismatch.");

	417 static_assert(NETWORK_CODE_CERT_CONTAINS_ERRORS ==

	418 static_cast<NetworkCode>(net::ERR_CERT_CONTAINS_ERRORS),

	419 "Network code enum mismatch.");

	420 static_assert(

	421 NETWORK_CODE_CERT_NO_REVOCATION_MECHANISM ==

	422 static_cast<NetworkCode>(net::ERR_CERT_NO_REVOCATION_MECHANISM),

	423 "Network code enum mismatch.");

	424 static_assert(

	425 NETWORK_CODE_CERT_UNABLE_TO_CHECK_REVOCATION ==

	426 static_cast<NetworkCode>(net::ERR_CERT_UNABLE_TO_CHECK_REVOCATION),

	427 "Network code enum mismatch.");

	428 static_assert(NETWORK_CODE_CERT_REVOKED ==

	429 static_cast<NetworkCode>(net::ERR_CERT_REVOKED),

	430 "Network code enum mismatch.");

	431 static_assert(NETWORK_CODE_CERT_INVALID ==

	432 static_cast<NetworkCode>(net::ERR_CERT_INVALID),

	433 "Network code enum mismatch.");

	434 static_assert(

	435 NETWORK_CODE_CERT_WEAK_SIGNATURE_ALGORITHM ==

	436 static_cast<NetworkCode>(net::ERR_CERT_WEAK_SIGNATURE_ALGORITHM),

	437 "Network code enum mismatch.");

	438 static_assert(NETWORK_CODE_CERT_NON_UNIQUE_NAME ==

	439 static_cast<NetworkCode>(net::ERR_CERT_NON_UNIQUE_NAME),

	440 "Network code enum mismatch.");

	441 static_assert(NETWORK_CODE_CERT_WEAK_KEY ==

	442 static_cast<NetworkCode>(net::ERR_CERT_WEAK_KEY),

	443 "Network code enum mismatch.");

	444 static_assert(

	445 NETWORK_CODE_CERT_NAME_CONSTRAINT_VIOLATION ==

	446 static_cast<NetworkCode>(net::ERR_CERT_NAME_CONSTRAINT_VIOLATION),

	447 "Network code enum mismatch.");

	448 static_assert(NETWORK_CODE_CERT_VALIDITY_TOO_LONG ==

	449 static_cast<NetworkCode>(net::ERR_CERT_VALIDITY_TOO_LONG),

	450 "Network code enum mismatch.");

	451 static_assert(

	452 NETWORK_CODE_CERT_END == static_cast<NetworkCode>(net::ERR_CERT_END),

	453 "Network code enum mismatch.");

	454 static_assert(NETWORK_CODE_INVALID_URL ==

	455 static_cast<NetworkCode>(net::ERR_INVALID_URL),

	456 "Network code enum mismatch.");

	457 static_assert(NETWORK_CODE_DISALLOWED_URL_SCHEME ==

	458 static_cast<NetworkCode>(net::ERR_DISALLOWED_URL_SCHEME),

	459 "Network code enum mismatch.");

	460 static_assert(NETWORK_CODE_UNKNOWN_URL_SCHEME ==

	461 static_cast<NetworkCode>(net::ERR_UNKNOWN_URL_SCHEME),

	462 "Network code enum mismatch.");

	463 static_assert(NETWORK_CODE_TOO_MANY_REDIRECTS ==

	464 static_cast<NetworkCode>(net::ERR_TOO_MANY_REDIRECTS),

	465 "Network code enum mismatch.");

	466 static_assert(NETWORK_CODE_UNSAFE_REDIRECT ==

	467 static_cast<NetworkCode>(net::ERR_UNSAFE_REDIRECT),

	468 "Network code enum mismatch.");

	469 static_assert(NETWORK_CODE_UNSAFE_PORT ==

	470 static_cast<NetworkCode>(net::ERR_UNSAFE_PORT),

	471 "Network code enum mismatch.");

	472 static_assert(NETWORK_CODE_INVALID_RESPONSE ==

	473 static_cast<NetworkCode>(net::ERR_INVALID_RESPONSE),

	474 "Network code enum mismatch.");

	475 static_assert(NETWORK_CODE_INVALID_CHUNKED_ENCODING ==

	476 static_cast<NetworkCode>(net::ERR_INVALID_CHUNKED_ENCODING),

	477 "Network code enum mismatch.");

	478 static_assert(NETWORK_CODE_METHOD_NOT_SUPPORTED ==

	479 static_cast<NetworkCode>(net::ERR_METHOD_NOT_SUPPORTED),

	480 "Network code enum mismatch.");

	481 static_assert(NETWORK_CODE_UNEXPECTED_PROXY_AUTH ==

	482 static_cast<NetworkCode>(net::ERR_UNEXPECTED_PROXY_AUTH),

	483 "Network code enum mismatch.");

	484 static_assert(NETWORK_CODE_EMPTY_RESPONSE ==

	485 static_cast<NetworkCode>(net::ERR_EMPTY_RESPONSE),

	486 "Network code enum mismatch.");

	487 static_assert(NETWORK_CODE_RESPONSE_HEADERS_TOO_BIG ==

	488 static_cast<NetworkCode>(net::ERR_RESPONSE_HEADERS_TOO_BIG),

	489 "Network code enum mismatch.");

	490 static_assert(NETWORK_CODE_PAC_STATUS_NOT_OK ==

	491 static_cast<NetworkCode>(net::ERR_PAC_STATUS_NOT_OK),

	492 "Network code enum mismatch.");

	493 static_assert(NETWORK_CODE_PAC_SCRIPT_FAILED ==

	494 static_cast<NetworkCode>(net::ERR_PAC_SCRIPT_FAILED),

	495 "Network code enum mismatch.");

	496 static_assert(

	497 NETWORK_CODE_REQUEST_RANGE_NOT_SATISFIABLE ==

	498 static_cast<NetworkCode>(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE),

	499 "Network code enum mismatch.");

	500 static_assert(NETWORK_CODE_MALFORMED_IDENTITY ==

	501 static_cast<NetworkCode>(net::ERR_MALFORMED_IDENTITY),

	502 "Network code enum mismatch.");

	503 static_assert(NETWORK_CODE_CONTENT_DECODING_FAILED ==

	504 static_cast<NetworkCode>(net::ERR_CONTENT_DECODING_FAILED),

	505 "Network code enum mismatch.");

	506 static_assert(NETWORK_CODE_NETWORK_IO_SUSPENDED ==

	507 static_cast<NetworkCode>(net::ERR_NETWORK_IO_SUSPENDED),

	508 "Network code enum mismatch.");

	509 static_assert(NETWORK_CODE_SYN_REPLY_NOT_RECEIVED ==

	510 static_cast<NetworkCode>(net::ERR_SYN_REPLY_NOT_RECEIVED),

	511 "Network code enum mismatch.");

	512 static_assert(

	513 NETWORK_CODE_ENCODING_CONVERSION_FAILED ==

	514 static_cast<NetworkCode>(net::ERR_ENCODING_CONVERSION_FAILED),

	515 "Network code enum mismatch.");

	516 static_assert(NETWORK_CODE_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT ==

	517 static_cast<NetworkCode>(

	518 net::ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT),

	519 "Network code enum mismatch.");

	520 static_assert(NETWORK_CODE_INVALID_SPDY_STREAM ==

	521 static_cast<NetworkCode>(net::ERR_INVALID_SPDY_STREAM),

	522 "Network code enum mismatch.");

	523 static_assert(NETWORK_CODE_NO_SUPPORTED_PROXIES ==

	524 static_cast<NetworkCode>(net::ERR_NO_SUPPORTED_PROXIES),

	525 "Network code enum mismatch.");

	526 static_assert(NETWORK_CODE_SPDY_PROTOCOL_ERROR ==

	527 static_cast<NetworkCode>(net::ERR_SPDY_PROTOCOL_ERROR),

	528 "Network code enum mismatch.");

	529 static_assert(NETWORK_CODE_INVALID_AUTH_CREDENTIALS ==

	530 static_cast<NetworkCode>(net::ERR_INVALID_AUTH_CREDENTIALS),

	531 "Network code enum mismatch.");

	532 static_assert(NETWORK_CODE_UNSUPPORTED_AUTH_SCHEME ==

	533 static_cast<NetworkCode>(net::ERR_UNSUPPORTED_AUTH_SCHEME),

	534 "Network code enum mismatch.");

	535 static_assert(

	536 NETWORK_CODE_ENCODING_DETECTION_FAILED ==

	537 static_cast<NetworkCode>(net::ERR_ENCODING_DETECTION_FAILED),

	538 "Network code enum mismatch.");

	539 static_assert(NETWORK_CODE_MISSING_AUTH_CREDENTIALS ==

	540 static_cast<NetworkCode>(net::ERR_MISSING_AUTH_CREDENTIALS),

	541 "Network code enum mismatch.");

	542 static_assert(

	543 NETWORK_CODE_UNEXPECTED_SECURITY_LIBRARY_STATUS ==

	544 static_cast<NetworkCode>(net::ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS),

	545 "Network code enum mismatch.");

	546 static_assert(

	547 NETWORK_CODE_MISCONFIGURED_AUTH_ENVIRONMENT ==

	548 static_cast<NetworkCode>(net::ERR_MISCONFIGURED_AUTH_ENVIRONMENT),

	549 "Network code enum mismatch.");

	550 static_assert(NETWORK_CODE_UNDOCUMENTED_SECURITY_LIBRARY_STATUS ==

	551 static_cast<NetworkCode>(

	552 net::ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS),

	553 "Network code enum mismatch.");

	554 static_assert(

	555 NETWORK_CODE_RESPONSE_BODY_TOO_BIG_TO_DRAIN ==

	556 static_cast<NetworkCode>(net::ERR_RESPONSE_BODY_TOO_BIG_TO_DRAIN),

	557 "Network code enum mismatch.");

	558 static_assert(NETWORK_CODE_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH ==

	559 static_cast<NetworkCode>(

	560 net::ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH),

	561 "Network code enum mismatch.");

	562 static_assert(NETWORK_CODE_INCOMPLETE_SPDY_HEADERS ==

	563 static_cast<NetworkCode>(net::ERR_INCOMPLETE_SPDY_HEADERS),

	564 "Network code enum mismatch.");

	565 static_assert(NETWORK_CODE_PAC_NOT_IN_DHCP ==

	566 static_cast<NetworkCode>(net::ERR_PAC_NOT_IN_DHCP),

	567 "Network code enum mismatch.");

	568 static_assert(NETWORK_CODE_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION ==

	569 static_cast<NetworkCode>(

	570 net::ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION),

	571 "Network code enum mismatch.");

	572 static_assert(

	573 NETWORK_CODE_RESPONSE_HEADERS_MULTIPLE_LOCATION ==

	574 static_cast<NetworkCode>(net::ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION),

	575 "Network code enum mismatch.");

	576 static_assert(

	577 NETWORK_CODE_SPDY_SERVER_REFUSED_STREAM ==

	578 static_cast<NetworkCode>(net::ERR_SPDY_SERVER_REFUSED_STREAM),

	579 "Network code enum mismatch.");

	580 static_assert(NETWORK_CODE_SPDY_PING_FAILED ==

	581 static_cast<NetworkCode>(net::ERR_SPDY_PING_FAILED),

	582 "Network code enum mismatch.");

	583 static_assert(NETWORK_CODE_CONTENT_LENGTH_MISMATCH ==

	584 static_cast<NetworkCode>(net::ERR_CONTENT_LENGTH_MISMATCH),

	585 "Network code enum mismatch.");

	586 static_assert(

	587 NETWORK_CODE_INCOMPLETE_CHUNKED_ENCODING ==

	588 static_cast<NetworkCode>(net::ERR_INCOMPLETE_CHUNKED_ENCODING),

	589 "Network code enum mismatch.");

	590 static_assert(NETWORK_CODE_QUIC_PROTOCOL_ERROR ==

	591 static_cast<NetworkCode>(net::ERR_QUIC_PROTOCOL_ERROR),

	592 "Network code enum mismatch.");

	593 static_assert(

	594 NETWORK_CODE_RESPONSE_HEADERS_TRUNCATED ==

	595 static_cast<NetworkCode>(net::ERR_RESPONSE_HEADERS_TRUNCATED),

	596 "Network code enum mismatch.");

	597 static_assert(NETWORK_CODE_QUIC_HANDSHAKE_FAILED ==

	598 static_cast<NetworkCode>(net::ERR_QUIC_HANDSHAKE_FAILED),

	599 "Network code enum mismatch.");

	600 static_assert(

	601 NETWORK_CODE_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC ==

	602 static_cast<NetworkCode>(

	603 net::ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC),

	604 "Network code enum mismatch.");

	605 static_assert(

	606 NETWORK_CODE_SPDY_INADEQUATE_TRANSPORT_SECURITY ==

	607 static_cast<NetworkCode>(net::ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY),

	608 "Network code enum mismatch.");

	609 static_assert(NETWORK_CODE_SPDY_FLOW_CONTROL_ERROR ==

	610 static_cast<NetworkCode>(net::ERR_SPDY_FLOW_CONTROL_ERROR),

	611 "Network code enum mismatch.");

	612 static_assert(NETWORK_CODE_SPDY_FRAME_SIZE_ERROR ==

	613 static_cast<NetworkCode>(net::ERR_SPDY_FRAME_SIZE_ERROR),

	614 "Network code enum mismatch.");

	615 static_assert(NETWORK_CODE_SPDY_COMPRESSION_ERROR ==

	616 static_cast<NetworkCode>(net::ERR_SPDY_COMPRESSION_ERROR),

	617 "Network code enum mismatch.");

	618 static_assert(NETWORK_CODE_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION ==

	619 static_cast<NetworkCode>(

	620 net::ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION),

	621 "Network code enum mismatch.");

	622 static_assert(NETWORK_CODE_HTTP_1_1_REQUIRED ==

	623 static_cast<NetworkCode>(net::ERR_HTTP_1_1_REQUIRED),

	624 "Network code enum mismatch.");

	625 static_assert(NETWORK_CODE_PROXY_HTTP_1_1_REQUIRED ==

	626 static_cast<NetworkCode>(net::ERR_PROXY_HTTP_1_1_REQUIRED),

	627 "Network code enum mismatch.");

	628 static_assert(

	629 NETWORK_CODE_CACHE_MISS == static_cast<NetworkCode>(net::ERR_CACHE_MISS),

	630 "Network code enum mismatch.");

	631 static_assert(NETWORK_CODE_CACHE_READ_FAILURE ==

	632 static_cast<NetworkCode>(net::ERR_CACHE_READ_FAILURE),

	633 "Network code enum mismatch.");

	634 static_assert(NETWORK_CODE_CACHE_WRITE_FAILURE ==

	635 static_cast<NetworkCode>(net::ERR_CACHE_WRITE_FAILURE),

	636 "Network code enum mismatch.");

	637 static_assert(

	638 NETWORK_CODE_CACHE_OPERATION_NOT_SUPPORTED ==

	639 static_cast<NetworkCode>(net::ERR_CACHE_OPERATION_NOT_SUPPORTED),

	640 "Network code enum mismatch.");

	641 static_assert(NETWORK_CODE_CACHE_OPEN_FAILURE ==

	642 static_cast<NetworkCode>(net::ERR_CACHE_OPEN_FAILURE),

	643 "Network code enum mismatch.");

	644 static_assert(NETWORK_CODE_CACHE_CREATE_FAILURE ==

	645 static_cast<NetworkCode>(net::ERR_CACHE_CREATE_FAILURE),

	646 "Network code enum mismatch.");

	647 static_assert(

	648 NETWORK_CODE_CACHE_RACE == static_cast<NetworkCode>(net::ERR_CACHE_RACE),

	649 "Network code enum mismatch.");

	650 static_assert(

	651 NETWORK_CODE_CACHE_CHECKSUM_READ_FAILURE ==

	652 static_cast<NetworkCode>(net::ERR_CACHE_CHECKSUM_READ_FAILURE),

	653 "Network code enum mismatch.");

	654 static_assert(NETWORK_CODE_CACHE_CHECKSUM_MISMATCH ==

	655 static_cast<NetworkCode>(net::ERR_CACHE_CHECKSUM_MISMATCH),

	656 "Network code enum mismatch.");

	657 static_assert(NETWORK_CODE_CACHE_LOCK_TIMEOUT ==

	658 static_cast<NetworkCode>(net::ERR_CACHE_LOCK_TIMEOUT),

	659 "Network code enum mismatch.");

	660 static_assert(NETWORK_CODE_INSECURE_RESPONSE ==

	661 static_cast<NetworkCode>(net::ERR_INSECURE_RESPONSE),

	662 "Network code enum mismatch.");

	663 static_assert(NETWORK_CODE_NO_PRIVATE_KEY_FOR_CERT ==

	664 static_cast<NetworkCode>(net::ERR_NO_PRIVATE_KEY_FOR_CERT),

	665 "Network code enum mismatch.");

	666 static_assert(NETWORK_CODE_ADD_USER_CERT_FAILED ==

	667 static_cast<NetworkCode>(net::ERR_ADD_USER_CERT_FAILED),

	668 "Network code enum mismatch.");

	669 static_assert(

	670 NETWORK_CODE_FTP_FAILED == static_cast<NetworkCode>(net::ERR_FTP_FAILED),

	671 "Network code enum mismatch.");

	672 static_assert(NETWORK_CODE_FTP_SERVICE_UNAVAILABLE ==

	673 static_cast<NetworkCode>(net::ERR_FTP_SERVICE_UNAVAILABLE),

	674 "Network code enum mismatch.");

	675 static_assert(NETWORK_CODE_FTP_TRANSFER_ABORTED ==

	676 static_cast<NetworkCode>(net::ERR_FTP_TRANSFER_ABORTED),

	677 "Network code enum mismatch.");

	678 static_assert(NETWORK_CODE_FTP_FILE_BUSY ==

	679 static_cast<NetworkCode>(net::ERR_FTP_FILE_BUSY),

	680 "Network code enum mismatch.");

	681 static_assert(NETWORK_CODE_FTP_SYNTAX_ERROR ==

	682 static_cast<NetworkCode>(net::ERR_FTP_SYNTAX_ERROR),

	683 "Network code enum mismatch.");

	684 static_assert(

	685 NETWORK_CODE_FTP_COMMAND_NOT_SUPPORTED ==

	686 static_cast<NetworkCode>(net::ERR_FTP_COMMAND_NOT_SUPPORTED),

	687 "Network code enum mismatch.");

	688 static_assert(NETWORK_CODE_FTP_BAD_COMMAND_SEQUENCE ==

	689 static_cast<NetworkCode>(net::ERR_FTP_BAD_COMMAND_SEQUENCE),

	690 "Network code enum mismatch.");

	691 static_assert(

	692 NETWORK_CODE_PKCS12_IMPORT_BAD_PASSWORD ==

	693 static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_BAD_PASSWORD),

	694 "Network code enum mismatch.");

	695 static_assert(NETWORK_CODE_PKCS12_IMPORT_FAILED ==

	696 static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_FAILED),

	697 "Network code enum mismatch.");

	698 static_assert(NETWORK_CODE_IMPORT_CA_CERT_NOT_CA ==

	699 static_cast<NetworkCode>(net::ERR_IMPORT_CA_CERT_NOT_CA),

	700 "Network code enum mismatch.");

	701 static_assert(

	702 NETWORK_CODE_IMPORT_CERT_ALREADY_EXISTS ==

	703 static_cast<NetworkCode>(net::ERR_IMPORT_CERT_ALREADY_EXISTS),

	704 "Network code enum mismatch.");

	705 static_assert(NETWORK_CODE_IMPORT_CA_CERT_FAILED ==

	706 static_cast<NetworkCode>(net::ERR_IMPORT_CA_CERT_FAILED),

	707 "Network code enum mismatch.");

	708 static_assert(

	709 NETWORK_CODE_IMPORT_SERVER_CERT_FAILED ==

	710 static_cast<NetworkCode>(net::ERR_IMPORT_SERVER_CERT_FAILED),

	711 "Network code enum mismatch.");

	712 static_assert(

	713 NETWORK_CODE_PKCS12_IMPORT_INVALID_MAC ==

	714 static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_INVALID_MAC),

	715 "Network code enum mismatch.");

	716 static_assert(

	717 NETWORK_CODE_PKCS12_IMPORT_INVALID_FILE ==

	718 static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_INVALID_FILE),

	719 "Network code enum mismatch.");

	720 static_assert(

	721 NETWORK_CODE_PKCS12_IMPORT_UNSUPPORTED ==

	722 static_cast<NetworkCode>(net::ERR_PKCS12_IMPORT_UNSUPPORTED),

	723 "Network code enum mismatch.");

	724 static_assert(NETWORK_CODE_KEY_GENERATION_FAILED ==

	725 static_cast<NetworkCode>(net::ERR_KEY_GENERATION_FAILED),

	726 "Network code enum mismatch.");

	727 static_assert(NETWORK_CODE_ORIGIN_BOUND_CERT_GENERATION_FAILED ==

	728 static_cast<NetworkCode>(

	729 net::ERR_ORIGIN_BOUND_CERT_GENERATION_FAILED),

	730 "Network code enum mismatch.");

	731 static_assert(

	732 NETWORK_CODE_PRIVATE_KEY_EXPORT_FAILED ==

	733 static_cast<NetworkCode>(net::ERR_PRIVATE_KEY_EXPORT_FAILED),

	734 "Network code enum mismatch.");

	735 static_assert(

	736 NETWORK_CODE_SELF_SIGNED_CERT_GENERATION_FAILED ==

	737 static_cast<NetworkCode>(net::ERR_SELF_SIGNED_CERT_GENERATION_FAILED),

	738 "Network code enum mismatch.");

	739 static_assert(NETWORK_CODE_CERT_DATABASE_CHANGED ==

	740 static_cast<NetworkCode>(net::ERR_CERT_DATABASE_CHANGED),

	741 "Network code enum mismatch.");

	742 static_assert(NETWORK_CODE_CHANNEL_ID_IMPORT_FAILED ==

	743 static_cast<NetworkCode>(net::ERR_CHANNEL_ID_IMPORT_FAILED),

	744 "Network code enum mismatch.");

	745 static_assert(NETWORK_CODE_DNS_MALFORMED_RESPONSE ==

	746 static_cast<NetworkCode>(net::ERR_DNS_MALFORMED_RESPONSE),

	747 "Network code enum mismatch.");

	748 static_assert(NETWORK_CODE_DNS_SERVER_REQUIRES_TCP ==

	749 static_cast<NetworkCode>(net::ERR_DNS_SERVER_REQUIRES_TCP),

	750 "Network code enum mismatch.");

	751 static_assert(NETWORK_CODE_DNS_SERVER_FAILED ==

	752 static_cast<NetworkCode>(net::ERR_DNS_SERVER_FAILED),

	753 "Network code enum mismatch.");

	754 static_assert(NETWORK_CODE_DNS_TIMED_OUT ==

	755 static_cast<NetworkCode>(net::ERR_DNS_TIMED_OUT),

	756 "Network code enum mismatch.");

	757 static_assert(NETWORK_CODE_DNS_CACHE_MISS ==

	758 static_cast<NetworkCode>(net::ERR_DNS_CACHE_MISS),

	759 "Network code enum mismatch.");

	760 static_assert(NETWORK_CODE_DNS_SEARCH_EMPTY ==

	761 static_cast<NetworkCode>(net::ERR_DNS_SEARCH_EMPTY),

	762 "Network code enum mismatch.");

	763 static_assert(NETWORK_CODE_DNS_SORT_ERROR ==

	764 static_cast<NetworkCode>(net::ERR_DNS_SORT_ERROR),

	765 "Network code enum mismatch.");

	766

111 NetworkErrorPtr error = NetworkError::New();	767 NetworkErrorPtr error = NetworkError::New();

112 error->code = error_code;	768 error->code = static_cast<NetworkCode>(error_code);

113 if (error_code <= 0)	769 if (error_code <= 0)

114 error->description = net::ErrorToString(error_code);	770 error->description = net::ErrorToString(error_code);

115 return error.Pass();	771 return error.Pass();

116 }	772 }

117	773

118 } // namespace mojo	774 } // namespace mojo

OLD	NEW

« 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 »