Use explicit WebString <-> string conversion methods for workers

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 137 matching lines @@
     RequestContextFrameType frame_type) {
   return static_cast<blink::WebURLRequest::FrameType>(frame_type);
 }
 
 blink::WebServiceWorkerClientInfo
 ToWebServiceWorkerClientInfo(const ServiceWorkerClientInfo& client_info) {
   DCHECK(client_info.IsValid());
 
   blink::WebServiceWorkerClientInfo web_client_info;
 
-  web_client_info.uuid = base::UTF8ToUTF16(client_info.client_uuid);
+  web_client_info.uuid = blink::WebString::fromASCII(client_info.client_uuid);
   web_client_info.pageVisibilityState = client_info.page_visibility_state;
   web_client_info.isFocused = client_info.is_focused;
   web_client_info.url = client_info.url;
   web_client_info.frameType = GetBlinkFrameType(client_info.frame_type);
   web_client_info.clientType = client_info.client_type;
 
   return web_client_info;
 }
 
 // Use this template in willDestroyWorkerContext to abort all the pending
@@ skipping 85 matching lines @@
     if (result_reported_)
       return;
     ServiceWorkerContextClient* client =
         ServiceWorkerContextClient::ThreadSpecificInstance();
     if (!client)
       return;
     client->OnNavigationPreloadError(
         fetch_event_id_,
         base::MakeUnique<blink::WebServiceWorkerError>(
             blink::WebServiceWorkerError::ErrorTypeAbort,
-            blink::WebString::fromUTF8(
+            blink::WebString::fromASCII(
                 "Service Worker navigation preload aborted. Need to guard with "
                 "respondWith or waitUntil.")));
   }
 
   void OnReceiveResponse(
       const ResourceResponseHead& response_head,
       mojom::DownloadedTempFilePtr downloaded_file) override {
     DCHECK(!response_);
     DCHECK(!downloaded_file);
     response_ = base::MakeUnique<blink::WebServiceWorkerResponse>();
@@ skipping 172 matching lines @@
 
 blink::WebURL ServiceWorkerContextClient::scope() const {
   return service_worker_scope_;
 }
 
 void ServiceWorkerContextClient::getClient(
     const blink::WebString& id,
     std::unique_ptr<blink::WebServiceWorkerClientCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id = context_->client_callbacks.Add(std::move(callbacks));
-  Send(new ServiceWorkerHostMsg_GetClient(
-      GetRoutingID(), request_id, base::UTF16ToUTF8(base::StringPiece16(id))));
+  Send(new ServiceWorkerHostMsg_GetClient(GetRoutingID(), request_id,
+                                          id.utf8()));

[kinuko, 2016/12/22 08:23:44]

These ids should be ascii-only, but since it's given from scripts we can't be
sure

 }
 
 void ServiceWorkerContextClient::getClients(
     const blink::WebServiceWorkerClientQueryOptions& weboptions,
     std::unique_ptr<blink::WebServiceWorkerClientsCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id = context_->clients_callbacks.Add(std::move(callbacks));
   ServiceWorkerClientQueryOptions options;
   options.client_type = weboptions.clientType;
   options.include_uncontrolled = weboptions.includeUncontrolled;
@@ skipping 154 matching lines @@
       base::Bind(&CallWorkerContextDestroyedOnMainThread,
                  embedded_worker_id_));
 }
 
 void ServiceWorkerContextClient::reportException(
     const blink::WebString& error_message,
     int line_number,
     int column_number,
     const blink::WebString& source_url) {
   Send(new EmbeddedWorkerHostMsg_ReportException(
-      embedded_worker_id_, error_message, line_number, column_number,
+      embedded_worker_id_, error_message.utf16(), line_number, column_number,
       blink::WebStringToGURL(source_url)));
 }
 
 void ServiceWorkerContextClient::reportConsoleMessage(
     int source,
     int level,
     const blink::WebString& message,
     int line_number,
     const blink::WebString& source_url) {
   EmbeddedWorkerHostMsg_ReportConsoleMessage_Params params;
   params.source_identifier = source;
   params.message_level = level;
-  params.message = message;
+  params.message = message.utf16();
   params.line_number = line_number;
   params.source_url = blink::WebStringToGURL(source_url);
 
   Send(new EmbeddedWorkerHostMsg_ReportConsoleMessage(
       embedded_worker_id_, params));
 }
 
 void ServiceWorkerContextClient::sendDevToolsMessage(
     int session_id,
     int call_id,
@@ skipping 177 matching lines @@
 void ServiceWorkerContextClient::postMessageToClient(
     const blink::WebString& uuid,
     const blink::WebString& message,
     blink::WebMessagePortChannelArray* channels) {
   // This may send channels for MessagePorts, and all internal book-keeping
   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
   // (with thread hopping), so we need to do the same thread hopping here not
   // to overtake those messages.
   std::unique_ptr<blink::WebMessagePortChannelArray> channel_array(channels);
   main_thread_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&SendPostMessageToClientOnMainThread,
-                            base::RetainedRef(sender_), GetRoutingID(),
-                            base::UTF16ToUTF8(base::StringPiece16(uuid)),
-                            static_cast<base::string16>(message),
-                            base::Passed(&channel_array)));
+      FROM_HERE,
+      base::Bind(&SendPostMessageToClientOnMainThread,
+                 base::RetainedRef(sender_), GetRoutingID(), uuid.utf8(),
+                 message.utf16(), base::Passed(&channel_array)));
 }
 
 void ServiceWorkerContextClient::focus(
     const blink::WebString& uuid,
     std::unique_ptr<blink::WebServiceWorkerClientCallbacks> callback) {
   DCHECK(callback);
   int request_id = context_->client_callbacks.Add(std::move(callback));
-  Send(new ServiceWorkerHostMsg_FocusClient(
-      GetRoutingID(), request_id,
-      base::UTF16ToUTF8(base::StringPiece16(uuid))));
+  Send(new ServiceWorkerHostMsg_FocusClient(GetRoutingID(), request_id,
+                                            uuid.utf8()));
 }
 
 void ServiceWorkerContextClient::navigate(
     const blink::WebString& uuid,
     const blink::WebURL& url,
     std::unique_ptr<blink::WebServiceWorkerClientCallbacks> callback) {
   DCHECK(callback);
   int request_id = context_->client_callbacks.Add(std::move(callback));
-  Send(new ServiceWorkerHostMsg_NavigateClient(
-      GetRoutingID(), request_id, base::UTF16ToUTF8(base::StringPiece16(uuid)),
-      url));
+  Send(new ServiceWorkerHostMsg_NavigateClient(GetRoutingID(), request_id,
+                                               uuid.utf8(), url));
 }
 
 void ServiceWorkerContextClient::skipWaiting(
     std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id = context_->skip_waiting_callbacks.Add(std::move(callbacks));
   Send(new ServiceWorkerHostMsg_SkipWaiting(GetRoutingID(), request_id));
 }
 
 void ServiceWorkerContextClient::claim(
@@ skipping 75 matching lines @@
       base::MakeUnique<DispatchExtendableMessageEventCallback>(callback));
 
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreatePorts(event->message_ports,
                                              event->new_routing_ids,
                                              main_thread_task_runner_);
   if (event->source.client_info.IsValid()) {
     blink::WebServiceWorkerClientInfo web_client =
         ToWebServiceWorkerClientInfo(event->source.client_info);
     proxy_->dispatchExtendableMessageEvent(
-        request_id, event->message, event->source_origin, ports, web_client);
+        request_id, blink::WebString::fromUTF16(event->message),
+        event->source_origin, ports, web_client);
     return;
   }
 
   DCHECK(event->source.service_worker_info.IsValid());
   std::unique_ptr<ServiceWorkerHandleReference> handle =
       ServiceWorkerHandleReference::Adopt(event->source.service_worker_info,
                                           sender_.get());
   ServiceWorkerDispatcher* dispatcher =
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
           sender_.get(), main_thread_task_runner_.get());
   scoped_refptr<WebServiceWorkerImpl> worker =
       dispatcher->GetOrCreateServiceWorker(std::move(handle));
   proxy_->dispatchExtendableMessageEvent(
-      request_id, event->message, event->source_origin, ports,
-      WebServiceWorkerImpl::CreateHandle(worker));
+      request_id, blink::WebString::fromUTF16(event->message),
+      event->source_origin, ports, WebServiceWorkerImpl::CreateHandle(worker));
 }
 
 void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnInstallEvent");
   proxy_->dispatchInstallEvent(request_id);
 }
 
 void ServiceWorkerContextClient::DispatchFetchEvent(
     int fetch_event_id,
@@ skipping 18 matching lines @@
 
   webRequest.setURL(blink::WebURL(request.url));
   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
   for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();
        it != request.headers.end();
        ++it) {
     webRequest.setHeader(blink::WebString::fromUTF8(it->first),
                          blink::WebString::fromUTF8(it->second));
   }
   if (!request.blob_uuid.empty()) {
-    webRequest.setBlob(blink::WebString::fromUTF8(request.blob_uuid),
+    webRequest.setBlob(blink::WebString::fromASCII(request.blob_uuid),
                        request.blob_size);
   }
   webRequest.setReferrer(
       blink::WebString::fromUTF8(request.referrer.url.spec()),
       request.referrer.policy);
   webRequest.setMode(GetBlinkFetchRequestMode(request.mode));
   webRequest.setIsMainResourceLoad(request.is_main_resource_load);
   webRequest.setCredentialsMode(
       GetBlinkFetchCredentialsMode(request.credentials_mode));
   webRequest.setRedirectMode(GetBlinkFetchRedirectMode(request.redirect_mode));
@@ skipping 14 matching lines @@
     int request_id,
     const std::string& notification_id,
     const PlatformNotificationData& notification_data,
     int action_index,
     const base::NullableString16& reply) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnNotificationClickEvent");
   proxy_->dispatchNotificationClickEvent(
       request_id, blink::WebString::fromUTF8(notification_id),
       ToWebNotificationData(notification_data), action_index,
-      blink::WebString(reply));
+      blink::WebString::fromUTF16(reply));
 }
 
 void ServiceWorkerContextClient::OnNotificationCloseEvent(
     int request_id,
     const std::string& notification_id,
     const PlatformNotificationData& notification_data) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnNotificationCloseEvent");
   proxy_->dispatchNotificationCloseEvent(
       request_id, blink::WebString::fromUTF8(notification_id),
@@ skipping 187 matching lines @@
     blink::WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnClaimClientsError");
   blink::WebServiceWorkerClientsClaimCallbacks* callbacks =
       context_->claim_clients_callbacks.Lookup(request_id);
   if (!callbacks) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
-  callbacks->onError(blink::WebServiceWorkerError(error_type, message));
+  callbacks->onError(blink::WebServiceWorkerError(
+      error_type, blink::WebString::fromUTF16(message)));
   context_->claim_clients_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::OnPing() {
   Send(new ServiceWorkerHostMsg_Pong(GetRoutingID()));
 }
 
 void ServiceWorkerContextClient::OnNavigationPreloadResponse(
     int fetch_event_id,
     std::unique_ptr<blink::WebServiceWorkerResponse> response,
@@ skipping 16 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content