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

content/child/service_worker/service_worker_dispatcher.cc

 // Copyright 2013 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/service_worker/service_worker_dispatcher.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 604 matching lines @@
                                "OnRegistrationError");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::RegisterServiceWorker",
                          request_id);
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onError(WebServiceWorkerError(error_type, message));
+  callbacks->onError(
+      WebServiceWorkerError(error_type, blink::WebString::fromUTF16(message)));
   pending_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUpdateError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::UpdateServiceWorker",
                                request_id, "OnUpdateError");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::UpdateServiceWorker",
                          request_id);
   WebServiceWorkerUpdateCallbacks* callbacks =
       pending_update_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onError(WebServiceWorkerError(error_type, message));
+  callbacks->onError(
+      WebServiceWorkerError(error_type, blink::WebString::fromUTF16(message)));
   pending_update_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistrationError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::UnregisterServiceWorker",
       request_id,
       "OnUnregistrationError");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::UnregisterServiceWorker",
                          request_id);
   WebServiceWorkerUnregistrationCallbacks* callbacks =
       pending_unregistration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onError(WebServiceWorkerError(error_type, message));
+  callbacks->onError(
+      WebServiceWorkerError(error_type, blink::WebString::fromUTF16(message)));
   pending_unregistration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnGetRegistrationError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistration",
       request_id,
       "OnGetRegistrationError");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistration",
                          request_id);
   WebServiceWorkerGetRegistrationCallbacks* callbacks =
       pending_get_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onError(WebServiceWorkerError(error_type, message));
+  callbacks->onError(
+      WebServiceWorkerError(error_type, blink::WebString::fromUTF16(message)));
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnGetRegistrationsError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrations",
       request_id,
       "OnGetRegistrationsError");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistrations",
                          request_id);
   WebServiceWorkerGetRegistrationsCallbacks* callbacks =
       pending_get_registrations_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onError(WebServiceWorkerError(error_type, message));
+  callbacks->onError(
+      WebServiceWorkerError(error_type, blink::WebString::fromUTF16(message)));
   pending_get_registrations_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnEnableNavigationPreloadError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const std::string& message) {
   WebEnableNavigationPreloadCallbacks* callbacks =
       enable_navigation_preload_callbacks_.Lookup(request_id);
@@ skipping 138 matching lines @@
     // client.
     return;
   }
 
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreatePorts(
           params.message_ports, params.new_routing_ids,
           base::ThreadTaskRunnerHandle::Get());
 
   found->second->dispatchMessageEvent(
-      WebServiceWorkerImpl::CreateHandle(worker), params.message, ports);
+      WebServiceWorkerImpl::CreateHandle(worker),
+      blink::WebString::fromUTF16(params.message), ports);
 }
 
 void ServiceWorkerDispatcher::AddServiceWorker(
     int handle_id, WebServiceWorkerImpl* worker) {
   DCHECK(!base::ContainsKey(service_workers_, handle_id));
   service_workers_[handle_id] = worker;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorker(int handle_id) {
   DCHECK(base::ContainsKey(service_workers_, handle_id));
@@ skipping 19 matching lines @@
   return ServiceWorkerRegistrationHandleReference::Adopt(
       info, thread_safe_sender_.get());
 }
 
 std::unique_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerObjectInfo& info) {
   return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
 }
 
 }  // namespace content