Use mojo for Chrome Loading, Part 1

content/common/url_loader_type_converters.cc

+// 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"
+#include "url/gurl.h"
+#include "url/origin.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(

[dcheng, 2016/05/11 17:05:18]

Let's avoid adding new type converters and use StructTraits instead.

[yhirano, 2016/05/16 14:40:06]

Done (using ipc paramtraits)

+    const ResourceHostMsg_Request& request) {
+  URLRequestPtr url_request(URLRequest::New());
+
+  url_request->method = request.method;
+  url_request->url = request.url.spec();
+  url_request->first_party_for_cookies = request.first_party_for_cookies.spec();
+  url_request->request_initiator = request.request_initiator.Serialize();
+  url_request->referrer = request.referrer.spec();
+  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 = GURL(request.url.get());
+  ipc_request.first_party_for_cookies =
+      GURL(std::string(request.first_party_for_cookies));
+  ipc_request.request_initiator =
+      url::Origin(GURL(std::string(request.request_initiator)));
+  ipc_request.referrer = GURL(std::string(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.spec();
+  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.spec();
+  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 =
+      GURL(std::string(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 =
+      GURL(std::string(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