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

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::fromUTF8(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;
 }
 
 }  // namespace
@@ skipping 258 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()));
 }
 
 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 161 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 176 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::postMessageToCrossOriginClient(
     const blink::WebCrossOriginServiceWorkerClient&,
     const blink::WebString&,
     blink::WebMessagePortChannelArray*) {
   NOTREACHED();
 }
 
 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 72 matching lines @@
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnExtendableMessageEvent");
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreatePorts(params.message_ports,
                                              params.new_routing_ids,
                                              main_thread_task_runner_);
   if (params.source.client_info.IsValid()) {
     blink::WebServiceWorkerClientInfo web_client =
         ToWebServiceWorkerClientInfo(params.source.client_info);
     proxy_->dispatchExtendableMessageEvent(
-        request_id, params.message, params.source_origin, ports, web_client);
+        request_id, blink::WebString::fromUTF16(params.message),
+        params.source_origin, ports, web_client);
     return;
   }
 
   DCHECK(params.source.service_worker_info.IsValid());
   std::unique_ptr<ServiceWorkerHandleReference> handle =
       ServiceWorkerHandleReference::Adopt(params.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, params.message, params.source_origin, ports,
-      WebServiceWorkerImpl::CreateHandle(worker));
+      request_id, blink::WebString::fromUTF16(params.message),
+      params.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 53 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 183 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