WebString: makes string16 conversions explicit (part 1: blink, content)

content/child/web_url_loader_impl.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 33 matching lines @@
 #include "net/base/filename_util.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/ct_sct_to_string.h"
 #include "net/cert/x509_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/url_request/url_request_data_job.h"
+#include "third_party/WebKit/public/platform/FilePathConversion.h"
+#include "third_party/WebKit/public/platform/StringVectorCopier.h"
 #include "third_party/WebKit/public/platform/WebHTTPLoadInfo.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebSecurityStyle.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLLoadTiming.h"
 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
@@ skipping 252 matching lines @@
   std::vector<std::string> san;
   bool rv = net::x509_util::ParseCertificateSandboxed(
       info.certificate[0], &subject, &issuer, &valid_start, &valid_expiry, &san,
       &san);
   if (!rv) {
     NOTREACHED();
     response->setSecurityStyle(blink::WebSecurityStyleUnknown);
     return;
   }
 
-  blink::WebVector<blink::WebString> web_san(san.size());
-  std::transform(
-      san.begin(),
-      san.end(), web_san.begin(),
-      [](const std::string& h) { return blink::WebString::fromLatin1(h); });
-
-  blink::WebVector<blink::WebString> web_cert(info.certificate.size());
-  std::transform(
-      info.certificate.begin(),
-      info.certificate.end(), web_cert.begin(),
-      [](const std::string& h) { return blink::WebString::fromLatin1(h); });
-
   blink::WebURLResponse::WebSecurityDetails webSecurityDetails(
       WebString::fromUTF8(protocol), WebString::fromUTF8(key_exchange),
-      WebString::fromUTF8(key_exchange_group),
-      WebString::fromUTF8(cipher), WebString::fromUTF8(mac),
-      WebString::fromUTF8(subject),
-      web_san,
-      WebString::fromUTF8(issuer),
-      valid_start.ToDoubleT(),
-      valid_expiry.ToDoubleT(),
-      web_cert,
-      sct_list);
+      WebString::fromUTF8(key_exchange_group), WebString::fromUTF8(cipher),
+      WebString::fromUTF8(mac), WebString::fromUTF8(subject),
+      blink::CopyStringVectorFromLatin1(san), WebString::fromUTF8(issuer),
+      valid_start.ToDoubleT(), valid_expiry.ToDoubleT(),
+      blink::CopyStringVectorFromLatin1(info.certificate), sct_list);
 
   response->setSecurityDetails(webSecurityDetails);
 }
 
 }  // namespace
 
 StreamOverrideParameters::StreamOverrideParameters() {}
 StreamOverrideParameters::~StreamOverrideParameters() {}
 
 // This inner class exists since the WebURLLoader may be deleted while inside a
@@ skipping 678 matching lines @@
   response->setHasMajorCertificateErrors(info.has_major_certificate_errors);
   response->setAppCacheID(info.appcache_id);
   response->setAppCacheManifestURL(info.appcache_manifest_url);
   response->setWasCached(!info.load_timing.request_start_time.is_null() &&
       info.response_time < info.load_timing.request_start_time);
   response->setRemoteIPAddress(
       WebString::fromUTF8(info.socket_address.HostForURL()));
   response->setRemotePort(info.socket_address.port());
   response->setConnectionID(info.load_timing.socket_log_id);
   response->setConnectionReused(info.load_timing.socket_reused);
-  response->setDownloadFilePath(info.download_file_path.AsUTF16Unsafe());
+  response->setDownloadFilePath(
+      blink::FilePathToWebString(info.download_file_path));
   response->setWasFetchedViaSPDY(info.was_fetched_via_spdy);
   response->setWasFetchedViaServiceWorker(info.was_fetched_via_service_worker);
   response->setWasFetchedViaForeignFetch(info.was_fetched_via_foreign_fetch);
   response->setWasFallbackRequiredByServiceWorker(
       info.was_fallback_required_by_service_worker);
   response->setServiceWorkerResponseType(info.response_type_via_service_worker);
   response->setOriginalURLViaServiceWorker(
       info.original_url_via_service_worker);
   response->setCacheStorageCacheName(
       info.is_in_cache_storage
           ? blink::WebString::fromUTF8(info.cache_storage_cache_name)
           : blink::WebString());
-  blink::WebVector<blink::WebString> cors_exposed_header_names(
-      info.cors_exposed_header_names.size());
-  std::transform(
-      info.cors_exposed_header_names.begin(),
-      info.cors_exposed_header_names.end(), cors_exposed_header_names.begin(),
-      [](const std::string& h) { return blink::WebString::fromLatin1(h); });
-  response->setCorsExposedHeaderNames(cors_exposed_header_names);
+  response->setCorsExposedHeaderNames(
+      blink::CopyStringVectorFromLatin1(info.cors_exposed_header_names));
   response->setEncodedDataLength(info.encoded_data_length);
 
   SetSecurityStyleAndDetails(url, info, response, report_security_info);
 
   WebURLResponseExtraDataImpl* extra_data =
       new WebURLResponseExtraDataImpl(info.alpn_negotiated_protocol);
   response->setExtraData(extra_data);
   extra_data->set_was_fetched_via_spdy(info.was_fetched_via_spdy);
   extra_data->set_was_alpn_negotiated(info.was_alpn_negotiated);
   extra_data->set_was_alternate_protocol_available(
@@ skipping 61 matching lines @@
   response->setHTTPVersion(version);
   response->setHTTPStatusCode(headers->response_code());
   response->setHTTPStatusText(WebString::fromLatin1(headers->GetStatusText()));
 
   // TODO(darin): We should leverage HttpResponseHeaders for this, and this
   // should be using the same code as ResourceDispatcherHost.
   // TODO(jungshik): Figure out the actual value of the referrer charset and
   // pass it to GetSuggestedFilename.
   std::string value;
   headers->EnumerateHeader(NULL, "content-disposition", &value);
-  response->setSuggestedFileName(
-      net::GetSuggestedFilename(url,
-                                value,
-                                std::string(),  // referrer_charset
-                                std::string(),  // suggested_name
-                                std::string(),  // mime_type
-                                std::string()));  // default_name
+  response->setSuggestedFileName(blink::WebString::fromUTF16(
+      net::GetSuggestedFilename(url, value,
+                                std::string(),     // referrer_charset
+                                std::string(),     // suggested_name
+                                std::string(),     // mime_type
+                                std::string())));  // default_name
 
   Time time_val;
   if (headers->GetLastModifiedValue(&time_val))
     response->setLastModifiedDate(time_val.ToDoubleT());
 
   // Build up the header map.
   size_t iter = 0;
   std::string name;
   while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
     response->addHTTPHeaderField(WebString::fromLatin1(name),
@@ skipping 85 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 void WebURLLoaderImpl::setLoadingTaskRunner(
     base::SingleThreadTaskRunner* loading_task_runner) {
   context_->SetTaskRunner(loading_task_runner);
 }
 
 }  // namespace content