Index: content/common/url_loader_type_converters.cc |
diff --git a/content/common/url_loader_type_converters.cc b/content/common/url_loader_type_converters.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..8e8b88ad904d34e6db1a2f71928269542a9cf2a7 |
--- /dev/null |
+++ b/content/common/url_loader_type_converters.cc |
@@ -0,0 +1,203 @@ |
+// Copyright 2016 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "content/common/url_loader_type_converters.h" |
+ |
+#include "base/strings/string_util.h" |
+#include "base/time/time.h" |
+#include "content/common/resource_messages.h" |
+#include "content/public/common/resource_response.h" |
+#include "net/http/http_response_headers.h" |
+#include "third_party/WebKit/public/platform/WebReferrerPolicy.h" |
+#include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponseType.h" |
+ |
+namespace mojo { |
+ |
+using content::mojom::URLLoaderStatus; |
+using content::mojom::URLLoaderStatusPtr; |
+using content::mojom::URLRequest; |
+using content::mojom::URLRequestPtr; |
+using content::mojom::URLResponse; |
+using content::mojom::URLResponsePtr; |
+ |
+#define CHECK_ENUM(blink_prefix, mojom_enum, name) \ |
+ static_assert(static_cast<int>(blink::blink_prefix##name) == \ |
+ static_cast<int>(content::mojom::mojom_enum::name), \ |
+ "Mismatched enum: " #blink_prefix #name " != " #mojom_enum \ |
+ "::" #name) |
+ |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, Always); |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, Default); |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, NoReferrerWhenDowngrade); |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, Never); |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, Origin); |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, OriginWhenCrossOrigin); |
+CHECK_ENUM(WebReferrerPolicy, |
+ ReferrerPolicy, |
+ NoReferrerWhenDowngradeOriginWhenCrossOrigin); |
+CHECK_ENUM(WebReferrerPolicy, ReferrerPolicy, Last); |
+ |
+CHECK_ENUM(WebServiceWorkerResponseType, ServiceWorkerResponseType, Basic); |
+CHECK_ENUM(WebServiceWorkerResponseType, ServiceWorkerResponseType, CORS); |
+CHECK_ENUM(WebServiceWorkerResponseType, ServiceWorkerResponseType, Default); |
+CHECK_ENUM(WebServiceWorkerResponseType, ServiceWorkerResponseType, Error); |
+CHECK_ENUM(WebServiceWorkerResponseType, ServiceWorkerResponseType, Opaque); |
+CHECK_ENUM(WebServiceWorkerResponseType, |
+ ServiceWorkerResponseType, |
+ OpaqueRedirect); |
+CHECK_ENUM(WebServiceWorkerResponseType, ServiceWorkerResponseType, Last); |
+ |
+URLRequestPtr TypeConverter<URLRequestPtr, ResourceHostMsg_Request>::Convert( |
+ const ResourceHostMsg_Request& request) { |
+ URLRequestPtr url_request(URLRequest::New()); |
+ |
+ url_request->method = request.method; |
+ url_request->url = request.url; |
+ url_request->first_party_for_cookies = request.first_party_for_cookies; |
+ url_request->request_initiator = request.request_initiator; |
+ url_request->referrer = request.referrer; |
+ url_request->referrer_policy = |
+ static_cast<content::mojom::ReferrerPolicy>(request.referrer_policy); |
+ |
+ return url_request; |
+} |
+ |
+ResourceHostMsg_Request |
+TypeConverter<ResourceHostMsg_Request, URLRequest>::Convert( |
+ const URLRequest& request) { |
+ ResourceHostMsg_Request ipc_request; |
+ ipc_request.method = request.method; |
+ ipc_request.url = request.url; |
+ ipc_request.first_party_for_cookies = request.first_party_for_cookies; |
+ ipc_request.request_initiator = request.request_initiator; |
+ ipc_request.referrer = request.referrer; |
+ ipc_request.referrer_policy = |
+ static_cast<blink::WebReferrerPolicy>(request.referrer_policy); |
+ |
+ return ipc_request; |
+} |
+ |
+URLResponsePtr |
+TypeConverter<URLResponsePtr, content::ResourceResponseHead>::Convert( |
+ const content::ResourceResponseHead& head) { |
+ URLResponsePtr response(URLResponse::New()); |
+ response->request_start = head.request_start.ToInternalValue(); |
+ response->response_start = head.response_start.ToInternalValue(); |
+ response->request_time = head.request_time.ToInternalValue(); |
+ response->response_time = head.response_time.ToInternalValue(); |
+ |
+ if (head.headers) { |
+ std::string headers; |
+ // See ParamTraits<scoped_refptr<net::HttpResponseHeaders>>::Write. |
+ head.headers->PersistTo(net::HttpResponseHeaders::PERSIST_SANS_COOKIES, |
+ &headers); |
+ response->headers = headers; |
+ } |
+ response->mime_type = head.mime_type; |
+ response->charset = head.charset; |
+ response->security_info = head.security_info; |
+ response->has_major_certificate_errors = head.has_major_certificate_errors; |
+ response->content_length = head.content_length; |
+ response->encoded_data_length = head.encoded_data_length; |
+ response->appcache_id = head.appcache_id; |
+ response->appcache_manifest_url = head.appcache_manifest_url; |
+ response->was_fetched_via_spdy = head.was_fetched_via_spdy; |
+ response->was_npn_negotiated = head.was_npn_negotiated; |
+ response->was_alternate_protocol_available = |
+ head.was_alternate_protocol_available; |
+ response->was_fetched_via_proxy = head.was_fetched_via_proxy; |
+ response->npn_negotiated_protocol = head.npn_negotiated_protocol; |
+ response->was_fetched_via_service_worker = |
+ head.was_fetched_via_service_worker; |
+ response->was_fallback_required_by_service_worker = |
+ head.was_fallback_required_by_service_worker; |
+ response->original_url_via_service_worker = |
+ head.original_url_via_service_worker; |
+ response->response_type_via_service_worker = |
+ static_cast<content::mojom::ServiceWorkerResponseType>( |
+ head.response_type_via_service_worker); |
+ response->service_worker_start_time = |
+ head.service_worker_start_time.ToInternalValue(); |
+ response->service_worker_ready_time = |
+ head.service_worker_ready_time.ToInternalValue(); |
+ response->is_in_cache_storage = head.is_in_cache_storage; |
+ response->cache_storage_cache_name = head.cache_storage_cache_name; |
+ response->is_using_lofi = head.is_using_lofi; |
+ |
+ return response; |
+} |
+ |
+content::ResourceResponseHead |
+TypeConverter<content::ResourceResponseHead, URLResponse>::Convert( |
+ const URLResponse& response) { |
+ content::ResourceResponseHead head; |
+ head.request_start = |
+ base::TimeTicks::FromInternalValue(response.request_start); |
+ head.response_start = |
+ base::TimeTicks::FromInternalValue(response.response_start); |
+ head.request_time = base::Time::FromInternalValue(response.request_time); |
+ head.response_time = base::Time::FromInternalValue(response.response_time); |
+ if (response.headers.size() > 0) |
+ head.headers = new net::HttpResponseHeaders(response.headers); |
+ head.mime_type = response.mime_type; |
+ head.charset = response.charset; |
+ head.security_info = response.security_info; |
+ head.has_major_certificate_errors = response.has_major_certificate_errors; |
+ head.content_length = response.content_length; |
+ head.encoded_data_length = response.encoded_data_length; |
+ head.appcache_id = response.appcache_id; |
+ head.appcache_manifest_url = response.appcache_manifest_url; |
+ head.was_fetched_via_spdy = response.was_fetched_via_spdy; |
+ head.was_npn_negotiated = response.was_npn_negotiated; |
+ head.was_alternate_protocol_available = |
+ response.was_alternate_protocol_available; |
+ head.was_fetched_via_proxy = response.was_fetched_via_proxy; |
+ head.npn_negotiated_protocol = response.npn_negotiated_protocol; |
+ head.was_fetched_via_service_worker = response.was_fetched_via_service_worker; |
+ head.was_fallback_required_by_service_worker = |
+ response.was_fallback_required_by_service_worker; |
+ head.original_url_via_service_worker = |
+ response.original_url_via_service_worker; |
+ head.response_type_via_service_worker = |
+ static_cast<blink::WebServiceWorkerResponseType>( |
+ response.response_type_via_service_worker); |
+ head.service_worker_start_time = |
+ base::TimeTicks::FromInternalValue(response.service_worker_start_time); |
+ head.service_worker_ready_time = |
+ base::TimeTicks::FromInternalValue(response.service_worker_ready_time); |
+ head.is_in_cache_storage = response.is_in_cache_storage; |
+ head.cache_storage_cache_name = response.cache_storage_cache_name; |
+ head.is_using_lofi = response.is_using_lofi; |
+ |
+ return head; |
+} |
+ |
+URLLoaderStatusPtr |
+TypeConverter<URLLoaderStatusPtr, ResourceMsg_RequestCompleteData>::Convert( |
+ const ResourceMsg_RequestCompleteData& data) { |
+ URLLoaderStatusPtr status(URLLoaderStatus::New()); |
+ status->network_error = data.error_code; |
+ status->was_ignored_by_handler = data.was_ignored_by_handler; |
+ status->exists_in_cache = data.exists_in_cache; |
+ status->security_info = data.security_info; |
+ status->completion_time = data.completion_time.ToInternalValue(); |
+ status->encoded_data_length = data.encoded_data_length; |
+ return status; |
+} |
+ |
+ResourceMsg_RequestCompleteData |
+TypeConverter<ResourceMsg_RequestCompleteData, URLLoaderStatus>::Convert( |
+ const URLLoaderStatus& status) { |
+ ResourceMsg_RequestCompleteData data; |
+ data.error_code = status.network_error; |
+ data.was_ignored_by_handler = status.was_ignored_by_handler; |
+ data.exists_in_cache = status.exists_in_cache; |
+ data.security_info = status.security_info; |
+ data.completion_time = |
+ base::TimeTicks::FromInternalValue(status.completion_time); |
+ data.encoded_data_length = status.encoded_data_length; |
+ return data; |
+} |
+ |
+} // namespace mojo |