content/renderer/service_worker/service_worker_script_context.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/service_worker/service_worker_script_context.h"
   6
   7 #include "base/logging.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/trace_event/trace_event.h"
  11 #include "content/child/notifications/notification_data_conversions.h"
  12 #include "content/child/service_worker/web_service_worker_registration_impl.h"
  13 #include "content/child/thread_safe_sender.h"
  14 #include "content/child/webmessageportchannel_impl.h"
  15 #include "content/common/message_port_messages.h"
  16 #include "content/common/service_worker/service_worker_messages.h"
  17 #include "content/public/common/referrer.h"
  18 #include "content/renderer/service_worker/embedded_worker_context_client.h"
  19 #include "ipc/ipc_message.h"
  20 #include "third_party/WebKit/public/platform/WebCrossOriginServiceWorkerClient.h"
  21 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
  22 #include "third_party/WebKit/public/platform/WebServiceWorkerClientQueryOptions.h"
  23 #include "third_party/WebKit/public/platform/WebServiceWorkerRequest.h"
  24 #include "third_party/WebKit/public/platform/WebString.h"
  25 #include "third_party/WebKit/public/platform/WebURL.h"
  26 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationData.h"
  27 #include "third_party/WebKit/public/web/WebServiceWorkerContextClient.h"
  28 #include "third_party/WebKit/public/web/WebServiceWorkerContextProxy.h"
  29
  30 namespace content {
  31
  32 namespace {
  33
  34 void SendPostMessageToClientOnMainThread(
  35     ThreadSafeSender* sender,
  36     int routing_id,
  37     const std::string& uuid,
  38     const base::string16& message,
  39     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
  40   sender->Send(new ServiceWorkerHostMsg_PostMessageToClient(
  41       routing_id, uuid, message,
  42       WebMessagePortChannelImpl::ExtractMessagePortIDs(channels.release())));
  43 }
  44
  45 void SendCrossOriginMessageToClientOnMainThread(
  46     ThreadSafeSender* sender,
  47     int message_port_id,
  48     const base::string16& message,
  49     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
  50   sender->Send(new MessagePortHostMsg_PostMessage(
  51       message_port_id,
  52       MessagePortMessage(message),
  53                          WebMessagePortChannelImpl::ExtractMessagePortIDs(
  54                              channels.release())));
  55 }
  56
  57 blink::WebURLRequest::FetchRequestMode GetBlinkFetchRequestMode(
  58     FetchRequestMode mode) {
  59   return static_cast<blink::WebURLRequest::FetchRequestMode>(mode);
  60 }
  61
  62 blink::WebURLRequest::FetchCredentialsMode GetBlinkFetchCredentialsMode(
  63     FetchCredentialsMode credentials_mode) {
  64   return static_cast<blink::WebURLRequest::FetchCredentialsMode>(
  65       credentials_mode);
  66 }
  67
  68 blink::WebURLRequest::RequestContext GetBlinkRequestContext(
  69     RequestContextType request_context_type) {
  70   return static_cast<blink::WebURLRequest::RequestContext>(
  71       request_context_type);
  72 }
  73
  74 blink::WebURLRequest::FrameType GetBlinkFrameType(
  75     RequestContextFrameType frame_type) {
  76   return static_cast<blink::WebURLRequest::FrameType>(frame_type);
  77 }
  78
  79 blink::WebServiceWorkerClientInfo
  80 ToWebServiceWorkerClientInfo(const ServiceWorkerClientInfo& client_info) {
  81   DCHECK(client_info.IsValid());
  82
  83   blink::WebServiceWorkerClientInfo web_client_info;
  84
  85   web_client_info.uuid = base::UTF8ToUTF16(client_info.client_uuid);
  86   web_client_info.pageVisibilityState = client_info.page_visibility_state;
  87   web_client_info.isFocused = client_info.is_focused;
  88   web_client_info.url = client_info.url;
  89   web_client_info.frameType = GetBlinkFrameType(client_info.frame_type);
  90   web_client_info.clientType = client_info.client_type;
  91
  92   return web_client_info;
  93 }
  94
  95 }  // namespace
  96
  97 ServiceWorkerScriptContext::ServiceWorkerScriptContext(
  98     EmbeddedWorkerContextClient* embedded_context,
  99     blink::WebServiceWorkerContextProxy* proxy)
 100     : embedded_context_(embedded_context),
 101       proxy_(proxy) {
 102 }
 103
 104 ServiceWorkerScriptContext::~ServiceWorkerScriptContext() {}
 105
 106 void ServiceWorkerScriptContext::OnMessageReceived(
 107     const IPC::Message& message) {
 108   bool handled = true;
 109   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerScriptContext, message)
 110     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
 111     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEvent)
 112     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
 113     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SyncEvent, OnSyncEvent)
 114     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
 115                         OnNotificationClickEvent)
 116     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
 117     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GeofencingEvent, OnGeofencingEvent)
 118     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginConnectEvent,
 119                         OnCrossOriginConnectEvent)
 120     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
 121     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginMessageToWorker,
 122                         OnCrossOriginMessageToWorker)
 123     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients,
 124                         OnDidGetClients)
 125     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
 126                         OnOpenWindowResponse)
 127     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
 128                         OnOpenWindowError)
 129     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
 130                         OnFocusClientResponse)
 131     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidSkipWaiting, OnDidSkipWaiting)
 132     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidClaimClients, OnDidClaimClients)
 133     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ClaimClientsError, OnClaimClientsError)
 134     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_Ping, OnPing);
 135     IPC_MESSAGE_UNHANDLED(handled = false)
 136   IPC_END_MESSAGE_MAP()
 137
 138   DCHECK(handled);
 139 }
 140
 141 void ServiceWorkerScriptContext::SetRegistrationInServiceWorkerGlobalScope(
 142     scoped_ptr<WebServiceWorkerRegistrationImpl> registration) {
 143   proxy_->setRegistration(registration.release());
 144 }
 145
 146 void ServiceWorkerScriptContext::DidHandleActivateEvent(
 147     int request_id,
 148     blink::WebServiceWorkerEventResult result) {
 149   UMA_HISTOGRAM_TIMES(
 150       "ServiceWorker.ActivateEventExecutionTime",
 151       base::TimeTicks::Now() - activate_start_timings_[request_id]);
 152   activate_start_timings_.erase(request_id);
 153
 154   Send(new ServiceWorkerHostMsg_ActivateEventFinished(
 155       GetRoutingID(), request_id, result));
 156 }
 157
 158 void ServiceWorkerScriptContext::DidHandleInstallEvent(
 159     int request_id,
 160     blink::WebServiceWorkerEventResult result) {
 161   UMA_HISTOGRAM_TIMES(
 162       "ServiceWorker.InstallEventExecutionTime",
 163       base::TimeTicks::Now() - install_start_timings_[request_id]);
 164   install_start_timings_.erase(request_id);
 165
 166   Send(new ServiceWorkerHostMsg_InstallEventFinished(
 167       GetRoutingID(), request_id, result));
 168 }
 169
 170 void ServiceWorkerScriptContext::DidHandleFetchEvent(
 171     int request_id,
 172     ServiceWorkerFetchEventResult result,
 173     const ServiceWorkerResponse& response) {
 174   UMA_HISTOGRAM_TIMES(
 175       "ServiceWorker.FetchEventExecutionTime",
 176       base::TimeTicks::Now() - fetch_start_timings_[request_id]);
 177   fetch_start_timings_.erase(request_id);
 178
 179   Send(new ServiceWorkerHostMsg_FetchEventFinished(
 180       GetRoutingID(), request_id, result, response));
 181 }
 182
 183 void ServiceWorkerScriptContext::DidHandleNotificationClickEvent(
 184     int request_id,
 185     blink::WebServiceWorkerEventResult result) {
 186   UMA_HISTOGRAM_TIMES(
 187       "ServiceWorker.NotificationClickEventExecutionTime",
 188       base::TimeTicks::Now() - notification_click_start_timings_[request_id]);
 189   notification_click_start_timings_.erase(request_id);
 190
 191   Send(new ServiceWorkerHostMsg_NotificationClickEventFinished(
 192       GetRoutingID(), request_id));
 193 }
 194
 195 void ServiceWorkerScriptContext::DidHandlePushEvent(
 196     int request_id,
 197     blink::WebServiceWorkerEventResult result) {
 198   if (result == blink::WebServiceWorkerEventResultCompleted) {
 199     UMA_HISTOGRAM_TIMES(
 200         "ServiceWorker.PushEventExecutionTime",
 201         base::TimeTicks::Now() - push_start_timings_[request_id]);
 202   }
 203   push_start_timings_.erase(request_id);
 204
 205   Send(new ServiceWorkerHostMsg_PushEventFinished(
 206       GetRoutingID(), request_id, result));
 207 }
 208
 209 void ServiceWorkerScriptContext::DidHandleSyncEvent(int request_id) {
 210   Send(new ServiceWorkerHostMsg_SyncEventFinished(
 211       GetRoutingID(), request_id));
 212 }
 213
 214 void ServiceWorkerScriptContext::DidHandleCrossOriginConnectEvent(
 215     int request_id,
 216     bool accept_connection) {
 217   Send(new ServiceWorkerHostMsg_CrossOriginConnectEventFinished(
 218       GetRoutingID(), request_id, accept_connection));
 219 }
 220
 221 void ServiceWorkerScriptContext::GetClients(
 222     const blink::WebServiceWorkerClientQueryOptions& weboptions,
 223     blink::WebServiceWorkerClientsCallbacks* callbacks) {
 224   DCHECK(callbacks);
 225   int request_id = pending_clients_callbacks_.Add(callbacks);
 226   ServiceWorkerClientQueryOptions options;
 227   options.client_type = weboptions.clientType;
 228   options.include_uncontrolled = weboptions.includeUncontrolled;
 229   Send(new ServiceWorkerHostMsg_GetClients(
 230       GetRoutingID(), request_id, options));
 231 }
 232
 233 void ServiceWorkerScriptContext::OpenWindow(
 234     const GURL& url, blink::WebServiceWorkerClientCallbacks* callbacks) {
 235   DCHECK(callbacks);
 236   int request_id = pending_client_callbacks_.Add(callbacks);
 237   Send(new ServiceWorkerHostMsg_OpenWindow(GetRoutingID(), request_id, url));
 238 }
 239
 240 void ServiceWorkerScriptContext::SetCachedMetadata(const GURL& url,
 241                                                    const char* data,
 242                                                    size_t size) {
 243   std::vector<char> copy(data, data + size);
 244   Send(new ServiceWorkerHostMsg_SetCachedMetadata(GetRoutingID(), url, copy));
 245 }
 246
 247 void ServiceWorkerScriptContext::ClearCachedMetadata(const GURL& url) {
 248   Send(new ServiceWorkerHostMsg_ClearCachedMetadata(GetRoutingID(), url));
 249 }
 250
 251 void ServiceWorkerScriptContext::PostMessageToClient(
 252     const base::string16& uuid,
 253     const base::string16& message,
 254     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
 255   // This may send channels for MessagePorts, and all internal book-keeping
 256   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
 257   // (with thread hopping), so we need to do the same thread hopping here not
 258   // to overtake those messages.
 259   embedded_context_->main_thread_task_runner()->PostTask(
 260       FROM_HERE,
 261       base::Bind(&SendPostMessageToClientOnMainThread,
 262                  make_scoped_refptr(embedded_context_->thread_safe_sender()),
 263                  GetRoutingID(),
 264                  base::UTF16ToUTF8(uuid),
 265                  message, base::Passed(&channels)));
 266 }
 267
 268 void ServiceWorkerScriptContext::PostCrossOriginMessageToClient(
 269     const blink::WebCrossOriginServiceWorkerClient& client,
 270     const base::string16& message,
 271     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
 272   // This may send channels for MessagePorts, and all internal book-keeping
 273   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
 274   // (with thread hopping), so we need to do the same thread hopping here not
 275   // to overtake those messages.
 276   embedded_context_->main_thread_task_runner()->PostTask(
 277       FROM_HERE,
 278       base::Bind(&SendCrossOriginMessageToClientOnMainThread,
 279                  make_scoped_refptr(embedded_context_->thread_safe_sender()),
 280                  client.clientID, message, base::Passed(&channels)));
 281 }
 282
 283 void ServiceWorkerScriptContext::FocusClient(
 284     const base::string16& uuid,
 285     blink::WebServiceWorkerClientCallbacks* callback) {
 286   DCHECK(callback);
 287   int request_id = pending_client_callbacks_.Add(callback);
 288   Send(new ServiceWorkerHostMsg_FocusClient(GetRoutingID(), request_id,
 289                                             base::UTF16ToUTF8(uuid)));
 290 }
 291
 292 void ServiceWorkerScriptContext::ClaimClients(
 293     blink::WebServiceWorkerClientsClaimCallbacks* callbacks) {
 294   DCHECK(callbacks);
 295   int request_id = pending_claim_clients_callbacks_.Add(callbacks);
 296   Send(new ServiceWorkerHostMsg_ClaimClients(GetRoutingID(), request_id));
 297 }
 298
 299 void ServiceWorkerScriptContext::SkipWaiting(
 300     blink::WebServiceWorkerSkipWaitingCallbacks* callbacks) {
 301   DCHECK(callbacks);
 302   int request_id = pending_skip_waiting_callbacks_.Add(callbacks);
 303   Send(new ServiceWorkerHostMsg_SkipWaiting(GetRoutingID(), request_id));
 304 }
 305
 306 void ServiceWorkerScriptContext::Send(IPC::Message* message) {
 307   embedded_context_->Send(message);
 308 }
 309
 310 int ServiceWorkerScriptContext::GetRoutingID() const {
 311   return embedded_context_->embedded_worker_id();
 312 }
 313
 314 void ServiceWorkerScriptContext::OnActivateEvent(int request_id) {
 315   TRACE_EVENT0("ServiceWorker",
 316                "ServiceWorkerScriptContext::OnActivateEvent");
 317   activate_start_timings_[request_id] = base::TimeTicks::Now();
 318   proxy_->dispatchActivateEvent(request_id);
 319 }
 320
 321 void ServiceWorkerScriptContext::OnInstallEvent(int request_id) {
 322   TRACE_EVENT0("ServiceWorker",
 323                "ServiceWorkerScriptContext::OnInstallEvent");
 324   install_start_timings_[request_id] = base::TimeTicks::Now();
 325   proxy_->dispatchInstallEvent(request_id);
 326 }
 327
 328 void ServiceWorkerScriptContext::OnFetchEvent(
 329     int request_id,
 330     const ServiceWorkerFetchRequest& request) {
 331   blink::WebServiceWorkerRequest webRequest;
 332   TRACE_EVENT0("ServiceWorker",
 333                "ServiceWorkerScriptContext::OnFetchEvent");
 334   webRequest.setURL(blink::WebURL(request.url));
 335   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
 336   for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();
 337        it != request.headers.end();
 338        ++it) {
 339     webRequest.setHeader(blink::WebString::fromUTF8(it->first),
 340                          blink::WebString::fromUTF8(it->second));
 341   }
 342   if (!request.blob_uuid.empty()) {
 343     webRequest.setBlob(blink::WebString::fromUTF8(request.blob_uuid),
 344                        request.blob_size);
 345   }
 346   webRequest.setReferrer(
 347       blink::WebString::fromUTF8(request.referrer.url.spec()),
 348       request.referrer.policy);
 349   webRequest.setMode(GetBlinkFetchRequestMode(request.mode));
 350   webRequest.setCredentialsMode(
 351       GetBlinkFetchCredentialsMode(request.credentials_mode));
 352   webRequest.setRequestContext(
 353       GetBlinkRequestContext(request.request_context_type));
 354   webRequest.setFrameType(GetBlinkFrameType(request.frame_type));
 355   webRequest.setIsReload(request.is_reload);
 356   fetch_start_timings_[request_id] = base::TimeTicks::Now();
 357   proxy_->dispatchFetchEvent(request_id, webRequest);
 358 }
 359
 360 void ServiceWorkerScriptContext::OnSyncEvent(int request_id) {
 361   TRACE_EVENT0("ServiceWorker",
 362                "ServiceWorkerScriptContext::OnSyncEvent");
 363   proxy_->dispatchSyncEvent(request_id);
 364 }
 365
 366 void ServiceWorkerScriptContext::OnNotificationClickEvent(
 367     int request_id,
 368     const std::string& notification_id,
 369     const PlatformNotificationData& notification_data) {
 370   TRACE_EVENT0("ServiceWorker",
 371                "ServiceWorkerScriptContext::OnNotificationClickEvent");
 372   notification_click_start_timings_[request_id] = base::TimeTicks::Now();
 373   proxy_->dispatchNotificationClickEvent(
 374       request_id,
 375       blink::WebString::fromUTF8(notification_id),
 376       ToWebNotificationData(notification_data));
 377 }
 378
 379 void ServiceWorkerScriptContext::OnPushEvent(int request_id,
 380                                              const std::string& data) {
 381   TRACE_EVENT0("ServiceWorker",
 382                "ServiceWorkerScriptContext::OnPushEvent");
 383   push_start_timings_[request_id] = base::TimeTicks::Now();
 384   proxy_->dispatchPushEvent(request_id, blink::WebString::fromUTF8(data));
 385 }
 386
 387 void ServiceWorkerScriptContext::OnGeofencingEvent(
 388     int request_id,
 389     blink::WebGeofencingEventType event_type,
 390     const std::string& region_id,
 391     const blink::WebCircularGeofencingRegion& region) {
 392   TRACE_EVENT0("ServiceWorker",
 393                "ServiceWorkerScriptContext::OnGeofencingEvent");
 394   proxy_->dispatchGeofencingEvent(
 395       request_id, event_type, blink::WebString::fromUTF8(region_id), region);
 396   Send(new ServiceWorkerHostMsg_GeofencingEventFinished(GetRoutingID(),
 397                                                         request_id));
 398 }
 399
 400 void ServiceWorkerScriptContext::OnCrossOriginConnectEvent(
 401     int request_id,
 402     const NavigatorConnectClient& client) {
 403   TRACE_EVENT0("ServiceWorker",
 404                "ServiceWorkerScriptContext::OnCrossOriginConnectEvent");
 405   blink::WebCrossOriginServiceWorkerClient web_client;
 406   web_client.origin = client.origin;
 407   web_client.targetURL = client.target_url;
 408   web_client.clientID = client.message_port_id;
 409   proxy_->dispatchCrossOriginConnectEvent(request_id, web_client);
 410 }
 411
 412 void ServiceWorkerScriptContext::OnPostMessage(
 413     const base::string16& message,
 414     const std::vector<TransferredMessagePort>& sent_message_ports,
 415     const std::vector<int>& new_routing_ids) {
 416   TRACE_EVENT0("ServiceWorker",
 417                "ServiceWorkerScriptContext::OnPostEvent");
 418   blink::WebMessagePortChannelArray ports =
 419       WebMessagePortChannelImpl::CreatePorts(
 420           sent_message_ports, new_routing_ids,
 421           embedded_context_->main_thread_task_runner());
 422
 423   // dispatchMessageEvent is expected to execute onmessage function
 424   // synchronously.
 425   base::TimeTicks before = base::TimeTicks::Now();
 426   proxy_->dispatchMessageEvent(message, ports);
 427   UMA_HISTOGRAM_TIMES(
 428       "ServiceWorker.MessageEventExecutionTime",
 429       base::TimeTicks::Now() - before);
 430 }
 431
 432 void ServiceWorkerScriptContext::OnCrossOriginMessageToWorker(
 433     const NavigatorConnectClient& client,
 434     const base::string16& message,
 435     const std::vector<TransferredMessagePort>& sent_message_ports,
 436     const std::vector<int>& new_routing_ids) {
 437   TRACE_EVENT0("ServiceWorker",
 438                "ServiceWorkerScriptContext::OnCrossOriginMessageToWorker");
 439   blink::WebMessagePortChannelArray ports =
 440       WebMessagePortChannelImpl::CreatePorts(
 441           sent_message_ports, new_routing_ids,
 442           embedded_context_->main_thread_task_runner());
 443
 444   blink::WebCrossOriginServiceWorkerClient web_client;
 445   web_client.origin = client.origin;
 446   web_client.targetURL = client.target_url;
 447   web_client.clientID = client.message_port_id;
 448   proxy_->dispatchCrossOriginMessageEvent(web_client, message, ports);
 449 }
 450
 451 void ServiceWorkerScriptContext::OnDidGetClients(
 452     int request_id, const std::vector<ServiceWorkerClientInfo>& clients) {
 453   TRACE_EVENT0("ServiceWorker",
 454                "ServiceWorkerScriptContext::OnDidGetClients");
 455   blink::WebServiceWorkerClientsCallbacks* callbacks =
 456       pending_clients_callbacks_.Lookup(request_id);
 457   if (!callbacks) {
 458     NOTREACHED() << "Got stray response: " << request_id;
 459     return;
 460   }
 461   scoped_ptr<blink::WebServiceWorkerClientsInfo> info(
 462       new blink::WebServiceWorkerClientsInfo);
 463   blink::WebVector<blink::WebServiceWorkerClientInfo> convertedClients(
 464       clients.size());
 465   for (size_t i = 0; i < clients.size(); ++i)
 466     convertedClients[i] = ToWebServiceWorkerClientInfo(clients[i]);
 467   info->clients.swap(convertedClients);
 468   callbacks->onSuccess(info.release());
 469   pending_clients_callbacks_.Remove(request_id);
 470 }
 471
 472 void ServiceWorkerScriptContext::OnOpenWindowResponse(
 473     int request_id,
 474     const ServiceWorkerClientInfo& client) {
 475   TRACE_EVENT0("ServiceWorker",
 476                "ServiceWorkerScriptContext::OnOpenWindowResponse");
 477   blink::WebServiceWorkerClientCallbacks* callbacks =
 478       pending_client_callbacks_.Lookup(request_id);
 479   if (!callbacks) {
 480     NOTREACHED() << "Got stray response: " << request_id;
 481     return;
 482   }
 483   scoped_ptr<blink::WebServiceWorkerClientInfo> web_client;
 484   if (!client.IsEmpty()) {
 485     DCHECK(client.IsValid());
 486     web_client.reset(new blink::WebServiceWorkerClientInfo(
 487         ToWebServiceWorkerClientInfo(client)));
 488   }
 489   callbacks->onSuccess(web_client.release());
 490   pending_client_callbacks_.Remove(request_id);
 491 }
 492
 493 void ServiceWorkerScriptContext::OnOpenWindowError(
 494     int request_id,
 495     const std::string& message) {
 496   TRACE_EVENT0("ServiceWorker",
 497                "ServiceWorkerScriptContext::OnOpenWindowError");
 498   blink::WebServiceWorkerClientCallbacks* callbacks =
 499       pending_client_callbacks_.Lookup(request_id);
 500   if (!callbacks) {
 501     NOTREACHED() << "Got stray response: " << request_id;
 502     return;
 503   }
 504   scoped_ptr<blink::WebServiceWorkerError> error(
 505       new blink::WebServiceWorkerError(
 506           blink::WebServiceWorkerError::ErrorTypeUnknown,
 507           blink::WebString::fromUTF8(message)));
 508   callbacks->onError(error.release());
 509   pending_client_callbacks_.Remove(request_id);
 510 }
 511
 512 void ServiceWorkerScriptContext::OnFocusClientResponse(
 513     int request_id, const ServiceWorkerClientInfo& client) {
 514   TRACE_EVENT0("ServiceWorker",
 515                "ServiceWorkerScriptContext::OnFocusClientResponse");
 516   blink::WebServiceWorkerClientCallbacks* callback =
 517       pending_client_callbacks_.Lookup(request_id);
 518   if (!callback) {
 519     NOTREACHED() << "Got stray response: " << request_id;
 520     return;
 521   }
 522   if (!client.IsEmpty()) {
 523     DCHECK(client.IsValid());
 524     scoped_ptr<blink::WebServiceWorkerClientInfo> web_client (
 525         new blink::WebServiceWorkerClientInfo(
 526             ToWebServiceWorkerClientInfo(client)));
 527     callback->onSuccess(web_client.release());
 528   } else {
 529     scoped_ptr<blink::WebServiceWorkerError> error(
 530         new blink::WebServiceWorkerError(
 531             blink::WebServiceWorkerError::ErrorTypeNotFound,
 532             "The WindowClient was not found."));
 533     callback->onError(error.release());
 534   }
 535
 536   pending_client_callbacks_.Remove(request_id);
 537 }
 538
 539 void ServiceWorkerScriptContext::OnDidSkipWaiting(int request_id) {
 540   TRACE_EVENT0("ServiceWorker",
 541                "ServiceWorkerScriptContext::OnDidSkipWaiting");
 542   blink::WebServiceWorkerSkipWaitingCallbacks* callbacks =
 543       pending_skip_waiting_callbacks_.Lookup(request_id);
 544   if (!callbacks) {
 545     NOTREACHED() << "Got stray response: " << request_id;
 546     return;
 547   }
 548   callbacks->onSuccess();
 549   pending_skip_waiting_callbacks_.Remove(request_id);
 550 }
 551
 552 void ServiceWorkerScriptContext::OnDidClaimClients(int request_id) {
 553   TRACE_EVENT0("ServiceWorker",
 554                "ServiceWorkerScriptContext::OnDidClaimClients");
 555   blink::WebServiceWorkerClientsClaimCallbacks* callbacks =
 556       pending_claim_clients_callbacks_.Lookup(request_id);
 557   if (!callbacks) {
 558     NOTREACHED() << "Got stray response: " << request_id;
 559     return;
 560   }
 561   callbacks->onSuccess();
 562   pending_claim_clients_callbacks_.Remove(request_id);
 563 }
 564
 565 void ServiceWorkerScriptContext::OnClaimClientsError(
 566     int request_id,
 567     blink::WebServiceWorkerError::ErrorType error_type,
 568     const base::string16& message) {
 569   TRACE_EVENT0("ServiceWorker",
 570                "ServiceWorkerScriptContext::OnClaimClientsError");
 571   blink::WebServiceWorkerClientsClaimCallbacks* callbacks =
 572       pending_claim_clients_callbacks_.Lookup(request_id);
 573   if (!callbacks) {
 574     NOTREACHED() << "Got stray response: " << request_id;
 575     return;
 576   }
 577   scoped_ptr<blink::WebServiceWorkerError> error(
 578       new blink::WebServiceWorkerError(error_type, message));
 579   callbacks->onError(error.release());
 580   pending_claim_clients_callbacks_.Remove(request_id);
 581 }
 582
 583 void ServiceWorkerScriptContext::OnPing() {
 584   Send(new ServiceWorkerHostMsg_Pong(GetRoutingID()));
 585 }
 586
 587 }  // namespace content