[ServiceWorker] Implement WebServiceWorkerContextClient::openWindow().

content/renderer/service_worker/service_worker_script_context.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/service_worker/service_worker_script_context.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "content/child/notifications/notification_data_conversions.h"
@@ skipping 84 matching lines @@
                         OnNotificationClickEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GeofencingEvent, OnGeofencingEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginConnectEvent,
                         OnCrossOriginConnectEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginMessageToWorker,
                         OnCrossOriginMessageToWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClientDocuments,
                         OnDidGetClientDocuments)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
+                        OnOpenWindowResponse)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
+                        OnOpenWindowError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
                         OnFocusClientResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidSkipWaiting, OnDidSkipWaiting)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   // TODO(gavinp): Would it be preferable to put an AddListener() method to
   // EmbeddedWorkerContextClient?
   if (!handled)
     handled = cache_storage_dispatcher_->OnMessageReceived(message);
@@ skipping 82 matching lines @@
 }
 
 void ServiceWorkerScriptContext::GetClientDocuments(
     blink::WebServiceWorkerClientsCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = pending_clients_callbacks_.Add(callbacks);
   Send(new ServiceWorkerHostMsg_GetClientDocuments(
       GetRoutingID(), request_id));
 }
 
+void ServiceWorkerScriptContext::OpenWindow(
+    const GURL& url, blink::WebServiceWorkerClientCallbacks* callbacks) {
+  DCHECK(callbacks);
+  int request_id = pending_client_callbacks_.Add(callbacks);
+  Send(new ServiceWorkerHostMsg_OpenWindow(GetRoutingID(), request_id, url));
+}
+
 void ServiceWorkerScriptContext::PostMessageToDocument(
     int client_id,
     const base::string16& message,
     scoped_ptr<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.
   embedded_context_->main_thread_proxy()->PostTask(
       FROM_HERE,
@@ skipping 201 matching lines @@
       new blink::WebServiceWorkerClientsInfo);
   blink::WebVector<blink::WebServiceWorkerClientInfo> convertedClients(
       clients.size());
   for (size_t i = 0; i < clients.size(); ++i)
     convertedClients[i] = clients[i];
   info->clients.swap(convertedClients);
   callbacks->onSuccess(info.release());
   pending_clients_callbacks_.Remove(request_id);
 }
 
+void ServiceWorkerScriptContext::OnOpenWindowResponse(
+    int request_id,
+    const ServiceWorkerClientInfo& client) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerScriptContext::OnOpenWindowResponse");
+  blink::WebServiceWorkerClientCallbacks* callbacks =
+      pending_client_callbacks_.Lookup(request_id);
+  if (!callbacks) {
+    NOTREACHED() << "Got stray response: " << request_id;
+    return;
+  }
+  scoped_ptr<blink::WebServiceWorkerClientInfo> web_client;
+  if (!client.IsEmpty()) {
+    DCHECK(client.IsValid());
+    web_client.reset(new blink::WebServiceWorkerClientInfo(client));
+  }
+  callbacks->onSuccess(web_client.release());
+  pending_client_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerScriptContext::OnOpenWindowError(int request_id) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerScriptContext::OnOpenWindowError");
+  blink::WebServiceWorkerClientCallbacks* callbacks =
+      pending_client_callbacks_.Lookup(request_id);
+  if (!callbacks) {
+    NOTREACHED() << "Got stray response: " << request_id;
+    return;
+  }
+  scoped_ptr<blink::WebServiceWorkerError> error(
+      new blink::WebServiceWorkerError(
+          blink::WebServiceWorkerError::ErrorTypeUnknown,
+          "Something went wrong while trying to open the window."));
+  callbacks->onError(error.release());
+  pending_client_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerScriptContext::OnFocusClientResponse(int request_id,
                                                        bool result) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnFocusClientResponse");
   blink::WebServiceWorkerClientFocusCallback* callback =
       pending_focus_client_callbacks_.Lookup(request_id);
   if (!callback) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
   callback->onSuccess(&result);
   pending_focus_client_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerScriptContext::OnDidSkipWaiting(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnDidSkipWaiting");
   blink::WebServiceWorkerSkipWaitingCallbacks* callbacks =
       pending_skip_waiting_callbacks_.Lookup(request_id);
   if (!callbacks) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
   callbacks->onSuccess();
   pending_skip_waiting_callbacks_.Remove(request_id);
 }
 
 }  // namespace content