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

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 <memory>
 #include <string>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_local.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/cache_storage/cache_storage_messages.h"
 #include "content/public/common/referrer.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/service_worker/service_worker_type_util.h"
+#include "third_party/WebKit/public/platform/StringVectorCopier.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;
@@ skipping 63 matching lines @@
       !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;
   query_params.ignore_vary = web_query_params.ignoreVary;
-  query_params.cache_name = web_query_params.cacheName;
+  query_params.cache_name =
+      blink::WebString::toNullableString16(web_query_params.cacheName);
   return query_params;
 }
 
 CacheStorageCacheOperationType CacheOperationTypeFromWebCacheOperationType(
     blink::WebServiceWorkerCache::OperationType operation_type) {
   switch (operation_type) {
     case blink::WebServiceWorkerCache::OperationTypePut:
       return CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     case blink::WebServiceWorkerCache::OperationTypeDelete:
       return CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE;
@@ skipping 201 matching lines @@
   callbacks->onSuccess();
   delete_callbacks_.Remove(request_id);
   delete_times_.erase(request_id);
 }
 
 void CacheStorageDispatcher::OnCacheStorageKeysSuccess(
     int thread_id,
     int request_id,
     const std::vector<base::string16>& keys) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
-  blink::WebVector<blink::WebString> webKeys(keys.size());
-  for (size_t i = 0; i < keys.size(); ++i)
-    webKeys[i] = keys[i];
+  blink::WebVector<blink::WebString> webKeys(
+      blink::CopyStringVectorFromUTF16(keys));
 
   UMA_HISTOGRAM_TIMES("ServiceWorkerCache.CacheStorage.Keys",
                       TimeTicks::Now() - keys_times_[request_id]);
   WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks* callbacks =
       keys_callbacks_.Lookup(request_id);
   callbacks->onSuccess(webKeys);
   keys_callbacks_.Remove(request_id);
   keys_times_.erase(request_id);
 }
 
@@ skipping 172 matching lines @@
 }
 
 void CacheStorageDispatcher::dispatchHas(
     std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageCallbacks>
         callbacks,
     const url::Origin& origin,
     const blink::WebString& cacheName) {
   int request_id = has_callbacks_.Add(std::move(callbacks));
   has_times_[request_id] = base::TimeTicks::Now();
   Send(new CacheStorageHostMsg_CacheStorageHas(CurrentWorkerId(), request_id,
-                                               origin, cacheName));
+                                               origin, cacheName.utf16()));
 }
 
 void CacheStorageDispatcher::dispatchOpen(
     std::unique_ptr<
         WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks> callbacks,
     const url::Origin& origin,
     const blink::WebString& cacheName) {
   int request_id = open_callbacks_.Add(std::move(callbacks));
   open_times_[request_id] = base::TimeTicks::Now();
   Send(new CacheStorageHostMsg_CacheStorageOpen(CurrentWorkerId(), request_id,
-                                                origin, cacheName));
+                                                origin, cacheName.utf16()));
 }
 
 void CacheStorageDispatcher::dispatchDelete(
     std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageCallbacks>
         callbacks,
     const url::Origin& origin,
     const blink::WebString& cacheName) {
   int request_id = delete_callbacks_.Add(std::move(callbacks));
   delete_times_[request_id] = base::TimeTicks::Now();
   Send(new CacheStorageHostMsg_CacheStorageDelete(CurrentWorkerId(), request_id,
-                                                  origin, cacheName));
+                                                  origin, cacheName.utf16()));
 }
 
 void CacheStorageDispatcher::dispatchKeys(
     std::unique_ptr<WebServiceWorkerCacheStorage::CacheStorageKeysCallbacks>
         callbacks,
     const url::Origin& origin) {
   int request_id = keys_callbacks_.Add(std::move(callbacks));
   keys_times_[request_id] = base::TimeTicks::Now();
   Send(new CacheStorageHostMsg_CacheStorageKeys(CurrentWorkerId(), request_id,
                                                 origin));
@@ skipping 88 matching lines @@
     blink::WebServiceWorkerResponse* web_response) {
   web_response->setURL(response.url);
   web_response->setStatus(response.status_code);
   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); });
+  blink::WebVector<blink::WebString> headers =
+      blink::CopyStringVectorFromLatin1(response.cors_exposed_header_names);
   web_response->setCorsExposedHeaderNames(headers);
 
   for (const auto& i : response.headers) {
     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