Skip base::string16 if not necessary for WebString <-> ASCII conversion

content/renderer/cache_storage/cache_storage_dispatcher.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/renderer/cache_storage/cache_storage_dispatcher.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <string>
@@ skipping 11 matching lines @@
 #include "content/renderer/service_worker/service_worker_type_util.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerCache.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "url/origin.h"
 
 using base::TimeTicks;
 
 namespace content {
 
+using blink::WebServiceWorkerCacheError;
 using blink::WebServiceWorkerCacheStorage;
-using blink::WebServiceWorkerCacheError;
 using blink::WebServiceWorkerRequest;
+using blink::WebString;
 
 static base::LazyInstance<base::ThreadLocalPointer<CacheStorageDispatcher>>::
     Leaky g_cache_storage_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
 
 namespace {
 
 CacheStorageDispatcher* const kHasBeenDeleted =
     reinterpret_cast<CacheStorageDispatcher*>(0x1);
 
 ServiceWorkerFetchRequest FetchRequestFromWebRequest(
     const blink::WebServiceWorkerRequest& web_request) {
   ServiceWorkerHeaderMap headers;
   GetServiceWorkerHeaderMapFromWebRequest(web_request, &headers);
 
   return ServiceWorkerFetchRequest(
-      web_request.url(),
-      base::UTF16ToASCII(base::StringPiece16(web_request.method())), headers,
+      web_request.url(), web_request.method().ascii(), headers,
       Referrer(web_request.referrerUrl(), web_request.referrerPolicy()),
       web_request.isReload());
 }
 
 void PopulateWebRequestFromFetchRequest(
     const ServiceWorkerFetchRequest& request,
     blink::WebServiceWorkerRequest* web_request) {
   web_request->setURL(request.url);
-  web_request->setMethod(base::ASCIIToUTF16(request.method));
+  web_request->setMethod(WebString::fromASCII(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->setHeader(WebString::fromASCII(i->first),
+                           WebString::fromASCII(i->second));
   }
-  web_request->setReferrer(base::ASCIIToUTF16(request.referrer.url.spec()),
+  web_request->setReferrer(WebString::fromASCII(request.referrer.url.spec()),
                            request.referrer.policy);
   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;
   GetServiceWorkerHeaderMapFromWebResponse(web_response, &headers);
   ServiceWorkerHeaderList cors_exposed_header_names;
   GetCorsExposedHeaderNamesFromWebResponse(web_response,
                                            &cors_exposed_header_names);
   // We don't support streaming for cache.
   DCHECK(web_response.streamURL().isEmpty());
   return ServiceWorkerResponse(
       web_response.url(), web_response.status(),
-      base::UTF16ToASCII(base::StringPiece16(web_response.statusText())),
-      web_response.responseType(), headers,
-      base::UTF16ToASCII(base::StringPiece16(web_response.blobUUID())),
-      web_response.blobSize(), web_response.streamURL(),
-      blink::WebServiceWorkerResponseErrorUnknown,
+      web_response.statusText().ascii(), web_response.responseType(), headers,
+      web_response.blobUUID().ascii(), web_response.blobSize(),
+      web_response.streamURL(), blink::WebServiceWorkerResponseErrorUnknown,
       base::Time::FromInternalValue(web_response.responseTime()),
       !web_response.cacheStorageCacheName().isNull(),
       web_response.cacheStorageCacheName().utf8(), cors_exposed_header_names);
 }
 
 CacheStorageCacheQueryParams QueryParamsFromWebQueryParams(
     const blink::WebServiceWorkerCache::QueryParams& web_query_params) {
   CacheStorageCacheQueryParams query_params;
   query_params.ignore_search = web_query_params.ignoreSearch;
   query_params.ignore_method = web_query_params.ignoreMethod;
@@ skipping 522 matching lines @@
 void CacheStorageDispatcher::OnWebCacheDestruction(int cache_id) {
   web_caches_.Remove(cache_id);
   Send(new CacheStorageHostMsg_CacheClosed(cache_id));
 }
 
 void CacheStorageDispatcher::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));
+  web_response->setStatusText(WebString::fromASCII(response.status_text));
   web_response->setResponseType(response.response_type);
   web_response->setResponseTime(response.response_time.ToInternalValue());
   web_response->setCacheStorageCacheName(
       response.is_in_cache_storage
           ? blink::WebString::fromUTF8(response.cache_storage_cache_name)
           : blink::WebString());
   blink::WebVector<blink::WebString> headers(
       response.cors_exposed_header_names.size());
   std::transform(
       response.cors_exposed_header_names.begin(),
       response.cors_exposed_header_names.end(), headers.begin(),
       [](const std::string& h) { return blink::WebString::fromLatin1(h); });
   web_response->setCorsExposedHeaderNames(headers);
 
   for (const auto& i : response.headers) {
-    web_response->setHeader(base::ASCIIToUTF16(i.first),
-                            base::ASCIIToUTF16(i.second));
+    web_response->setHeader(WebString::fromASCII(i.first),
+                            WebString::fromASCII(i.second));
   }
 
   if (!response.blob_uuid.empty()) {
     web_response->setBlob(blink::WebString::fromUTF8(response.blob_uuid),
                           response.blob_size);
     // Let the host know that it can release its reference to the blob.
     Send(new CacheStorageHostMsg_BlobDataHandled(response.blob_uuid));
   }
 }
 
 blink::WebVector<blink::WebServiceWorkerResponse>
 CacheStorageDispatcher::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;
 }
 
 }  // namespace content