+class HeaderVisitor : public blink::WebHTTPHeaderVisitor {
+ public:
+ HeaderVisitor(ServiceWorkerHeaderMap* headers) : headers_(headers) {}
+ virtual ~HeaderVisitor() {}
+
+ virtual void visitHeader(const blink::WebString& name,
+ const blink::WebString& value) {
+ headers_->insert(ServiceWorkerHeaderMap::value_type(
+ base::UTF16ToASCII(name), base::UTF16ToASCII(value)));
+ }
+
+ private:
+ ServiceWorkerHeaderMap* headers_;
+};
+
+scoped_ptr<HeaderVisitor> MakeHeaderVisitor(ServiceWorkerHeaderMap* headers) {
+ return scoped_ptr<HeaderVisitor>(new HeaderVisitor(headers)).Pass();
+}
+
+ServiceWorkerFetchRequest FetchRequestFromWebRequest(
+ const blink::WebServiceWorkerRequest& web_request) {
+ ServiceWorkerHeaderMap headers;
+ web_request.visitHTTPHeaderFields(MakeHeaderVisitor(&headers).get());
+
+ return ServiceWorkerFetchRequest(web_request.url(),
+ base::UTF16ToASCII(web_request.method()),
+ headers, web_request.referrerUrl(),
+ web_request.isReload());
+}
+
+void PopulateWebRequestFromFetchRequest(
+ const ServiceWorkerFetchRequest& request,
+ blink::WebServiceWorkerRequest* web_request) {
+ web_request->setURL(request.url);
+ web_request->setMethod(base::ASCIIToUTF16(request.method));
+ for (ServiceWorkerHeaderMap::const_iterator i = request.headers.begin(),
+ end = request.headers.end();
+ i != end; ++i) {
+ web_request->setHeader(base::ASCIIToUTF16(i->first),
+ base::ASCIIToUTF16(i->second));
+ }
+ web_request->setReferrer(base::ASCIIToUTF16(request.referrer.spec()),
+ blink::WebReferrerPolicy::WebReferrerPolicyNever);
+ web_request->setIsReload(request.is_reload);
+}
+
+blink::WebVector<blink::WebServiceWorkerRequest> WebRequestsFromRequests(
+ const std::vector<ServiceWorkerFetchRequest>& requests) {
+ blink::WebVector<blink::WebServiceWorkerRequest>
+ web_requests(requests.size());
+ for (size_t i = 0; i < requests.size(); ++i)
+ PopulateWebRequestFromFetchRequest(requests[i], &(web_requests[i]));
+ return web_requests;
+}
+
+ServiceWorkerResponse ResponseFromWebResponse(
+ const blink::WebServiceWorkerResponse& web_response) {
+ ServiceWorkerHeaderMap headers;
+ web_response.visitHTTPHeaderFields(MakeHeaderVisitor(&headers).get());
+
+ return ServiceWorkerResponse(
+ web_response.url(), web_response.status(),
+ base::UTF16ToASCII(web_response.statusText()), headers,
+ base::UTF16ToASCII(web_response.blobUUID()));
+}
+
+void PopulateWebResponseFromResponse(
+ const ServiceWorkerResponse& response,
+ blink::WebServiceWorkerResponse* web_response) {
+ web_response->setURL(response.url);
+ web_response->setStatus(response.status_code);
+ web_response->setStatusText(base::ASCIIToUTF16(response.status_text));
+ for (ServiceWorkerHeaderMap::const_iterator i = response.headers.begin(),
+ end = response.headers.end();
+ i != end; ++i) {
+ web_response->setHeader(base::ASCIIToUTF16(i->first),
+ base::ASCIIToUTF16(i->second));
+ }
+ // TODO(gavinp): set blob here.
+}
+
+blink::WebVector<blink::WebServiceWorkerResponse> WebResponsesFromResponses(
+ const std::vector<ServiceWorkerResponse>& responses) {
+ blink::WebVector<blink::WebServiceWorkerResponse>
+ web_responses(responses.size());
+ for (size_t i = 0; i < responses.size(); ++i)
+ PopulateWebResponseFromResponse(responses[i], &(web_responses[i]));
+ return web_responses;
+}
+
+ServiceWorkerCacheQueryParams QueryParamsFromWebQueryParams(
+ const blink::WebServiceWorkerCache::QueryParams& web_query_params) {
+ ServiceWorkerCacheQueryParams query_params;
+ query_params.ignore_search = web_query_params.ignoreSearch;
+ query_params.ignore_method = web_query_params.ignoreMethod;
+ query_params.ignore_vary = web_query_params.ignoreVary;
+ query_params.prefix_match = web_query_params.prefixMatch;
+
+ return query_params;
+}
+
+ServiceWorkerCacheOperationType CacheOperationTypeFromWebCacheOperationType(
+ blink::WebServiceWorkerCache::OperationType operation_type) {
+ switch (operation_type) {
+ case blink::WebServiceWorkerCache::OperationTypePut:
+ return SERVICE_WORKER_CACHE_OPERATION_TYPE_PUT;
+ case blink::WebServiceWorkerCache::OperationTypeDelete:
+ return SERVICE_WORKER_CACHE_OPERATION_TYPE_DELETE;
+ default:
+ return SERVICE_WORKER_CACHE_OPERATION_TYPE_UNDEFINED;
+ }
+}
+
+ServiceWorkerBatchOperation BatchOperationFromWebBatchOperation(
+ const blink::WebServiceWorkerCache::BatchOperation& web_operation) {
+ ServiceWorkerBatchOperation operation;
+ operation.operation_type =
+ CacheOperationTypeFromWebCacheOperationType(web_operation.operationType);
+ operation.request = FetchRequestFromWebRequest(web_operation.request);
+ operation.response = ResponseFromWebResponse(web_operation.response);
+ operation.match_params =
+ QueryParamsFromWebQueryParams(web_operation.matchParams);
+ return operation;
+}
+