Use explicit WebString <-> string{16,} conversion methods for WebURLLoader files

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/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 162 matching lines @@
   info->encoded_body_length = 0;
 
   return net::OK;
 }
 
 // Convert a net::SignedCertificateTimestampAndStatus object to a
 // blink::WebURLResponse::SignedCertificateTimestamp object.
 blink::WebURLResponse::SignedCertificateTimestamp NetSCTToBlinkSCT(
     const net::SignedCertificateTimestampAndStatus& sct_and_status) {
   return blink::WebURLResponse::SignedCertificateTimestamp(
-      WebString::fromUTF8(net::ct::StatusToString(sct_and_status.status)),
-      WebString::fromUTF8(net::ct::OriginToString(sct_and_status.sct->origin)),
+      WebString::fromASCII(net::ct::StatusToString(sct_and_status.status)),
+      WebString::fromASCII(net::ct::OriginToString(sct_and_status.sct->origin)),
       WebString::fromUTF8(sct_and_status.sct->log_description),
-      WebString::fromUTF8(base::HexEncode(sct_and_status.sct->log_id.c_str(),
-                                          sct_and_status.sct->log_id.length())),
+      WebString::fromASCII(
+          base::HexEncode(sct_and_status.sct->log_id.c_str(),
+                          sct_and_status.sct->log_id.length())),
       sct_and_status.sct->timestamp.ToJavaTime(),
-      WebString::fromUTF8(net::ct::HashAlgorithmToString(
+      WebString::fromASCII(net::ct::HashAlgorithmToString(
           sct_and_status.sct->signature.hash_algorithm)),
-      WebString::fromUTF8(net::ct::SignatureAlgorithmToString(
+      WebString::fromASCII(net::ct::SignatureAlgorithmToString(
           sct_and_status.sct->signature.signature_algorithm)),
-      WebString::fromUTF8(
-          base::HexEncode(sct_and_status.sct->signature.signature_data.c_str(),
+      WebString::fromASCII(base::HexEncode(
+          sct_and_status.sct->signature.signature_data.c_str(),
           sct_and_status.sct->signature.signature_data.length())));
 }
 
 void SetSecurityStyleAndDetails(const GURL& url,
                                 const ResourceResponseInfo& info,
                                 WebURLResponse* response,
                                 bool report_security_info) {
   if (!report_security_info) {
     response->setSecurityStyle(blink::WebSecurityStyleUnknown);
     return;
@@ skipping 71 matching lines @@
       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::fromASCII(protocol), WebString::fromASCII(key_exchange),
+      WebString::fromASCII(key_exchange_group), WebString::fromASCII(cipher),
+      WebString::fromASCII(mac), WebString::fromUTF8(subject), web_san,
+      WebString::fromUTF8(issuer), valid_start.ToDoubleT(),
+      valid_expiry.ToDoubleT(), web_cert, sct_list);
 
   response->setSecurityDetails(webSecurityDetails);
 }
 
 }  // namespace
 
 StreamOverrideParameters::StreamOverrideParameters() {}
 StreamOverrideParameters::~StreamOverrideParameters() {}
 
 // This inner class exists since the WebURLLoader may be deleted while inside a
@@ skipping 179 matching lines @@
 
 
   // PlzNavigate: outside of tests, the only navigation requests going through
   // the WebURLLoader are the ones created by CommitNavigation. Several browser
   // tests load HTML directly through a data url which will be handled by the
   // block above.
   DCHECK(!IsBrowserSideNavigationEnabled() || stream_override_.get() ||
          request.getFrameType() == WebURLRequest::FrameTypeNone);
 
   GURL referrer_url(
-      request.httpHeaderField(WebString::fromUTF8("Referer")).latin1());
+      request.httpHeaderField(WebString::fromASCII("Referer")).latin1());

[yhirano, 2016/12/26 03:36:22]

WebString::fromASCII(c_str).latin1() looks identical to std::string(c_str),
right?

[kinuko, 2016/12/26 07:28:05]

This gets the latin1 of request.httpHeaderField(), so not really.

[yhirano, 2016/12/26 07:38:59]

Ah, I see. Thanks.

   const std::string& method = request.httpMethod().latin1();
 
   // TODO(brettw) this should take parameter encoding into account when
   // creating the GURLs.
 
   // TODO(horo): Check credentials flag is unset when credentials mode is omit.
   //             Check credentials flag is set when credentials mode is include.
 
   std::unique_ptr<ResourceRequest> resource_request(new ResourceRequest);
 
@@ skipping 488 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->setURLListViaServiceWorker(info.url_list_via_service_worker);
   response->setCacheStorageCacheName(
       info.is_in_cache_storage
           ? blink::WebString::fromUTF8(info.cache_storage_cache_name)
@@ skipping 79 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 41 matching lines @@
   SyncLoadResponse sync_load_response;
   context_->Start(request, &sync_load_response);
 
   const GURL& final_url = sync_load_response.url;
 
   // TODO(tc): For file loads, we may want to include a more descriptive
   // status code or status text.
   int error_code = sync_load_response.error_code;
   if (error_code != net::OK) {
     response.setURL(final_url);
-    error.domain = WebString::fromUTF8(net::kErrorDomain);
+    error.domain = WebString::fromASCII(net::kErrorDomain);
     error.reason = error_code;
     error.unreachableURL = final_url;
     return;
   }
 
   PopulateURLResponse(final_url, sync_load_response, &response,
                       request.reportRawHeaders());
   response.addToDecodedBodyLength(sync_load_response.data.size());
   encoded_data_length = sync_load_response.encoded_data_length;
   encoded_body_length = sync_load_response.encoded_body_length;
@@ skipping 23 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