[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 52 matching lines @@
     RequestContextType request_context_type) {
   return static_cast<blink::WebURLRequest::RequestContext>(
       request_context_type);
 }
 
 blink::WebURLRequest::FrameType GetBlinkFrameType(
     RequestContextFrameType frame_type) {
   return static_cast<blink::WebURLRequest::FrameType>(frame_type);
 }
 
+blink::WebServiceWorkerClientInfo ToWebServiceWorkerClientInfo(
+    const ServiceWorkerClientInfo& client) {
+  blink::WebServiceWorkerClientInfo web_client;
+
+  web_client.clientID = client.client_id;
+  web_client.pageVisibilityState = client.page_visibility_state;
+  web_client.isFocused = client.is_focused;
+  web_client.url = client.url;
+  web_client.frameType = GetBlinkFrameType(client.frame_type);
+
+  return web_client;
+}
+
 }  // namespace
 
 ServiceWorkerScriptContext::ServiceWorkerScriptContext(
     EmbeddedWorkerContextClient* embedded_context,
     blink::WebServiceWorkerContextProxy* proxy)
     : cache_storage_dispatcher_(new ServiceWorkerCacheStorageDispatcher(this)),
       embedded_context_(embedded_context),
       proxy_(proxy) {
 }
 
@@ skipping 11 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 77 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,
+    const GURL& referrer,
+    blink::WebServiceWorkerClientCallbacks* callbacks) {
+  DCHECK(callbacks);
+  int request_id = pending_client_callbacks_.Add(callbacks);
+  Send(new ServiceWorkerHostMsg_OpenWindow(
+      GetRoutingID(), request_id, url, referrer));
+}
+
 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 194 matching lines @@
   blink::WebServiceWorkerClientsCallbacks* callbacks =
       pending_clients_callbacks_.Lookup(request_id);
   if (!callbacks) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
   scoped_ptr<blink::WebServiceWorkerClientsInfo> info(
       new blink::WebServiceWorkerClientsInfo);
   blink::WebVector<blink::WebServiceWorkerClientInfo> convertedClients(
       clients.size());
-  for (size_t i = 0; i < clients.size(); ++i) {
-    convertedClients[i].clientID = clients[i].client_id;
-    convertedClients[i].pageVisibilityState = clients[i].page_visibility_state;
-    convertedClients[i].isFocused = clients[i].is_focused;
-    convertedClients[i].url = clients[i].url;
-    convertedClients[i].frameType =
-        static_cast<blink::WebURLRequest::FrameType>(clients[i].frame_type);
-  }
+  for (size_t i = 0; i < clients.size(); ++i)
+    convertedClients[i] = ToWebServiceWorkerClientInfo(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, bool dummy_client) {

[nasko, 2015/01/17 00:05:28]

nit: if params don't fit on the line of the method, each param gets its own line

[mlamouri (slow - plz ping), 2015/01/26 13:19:08]

Done.

+  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(
+      new blink::WebServiceWorkerClientInfo(
+          ToWebServiceWorkerClientInfo(client)));
+  callbacks->onSuccess(dummy_client ? nullptr : 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