Service Worker: Add Clients.get(id)

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 <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 248 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
                         OnNotificationClickEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationCloseEvent,
                         OnNotificationCloseEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GeofencingEvent, OnGeofencingEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginMessageToWorker,
                         OnCrossOriginMessageToWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClient, OnDidGetClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients, OnDidGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
                         OnOpenWindowResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
                         OnOpenWindowError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
                         OnFocusClientResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NavigateClientResponse,
                         OnNavigateClientResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NavigateClientError,
@@ skipping 12 matching lines @@
     mojo::shell::mojom::InterfaceProviderPtr exposed_services) {
   context_->service_registry.Bind(std::move(services));
   context_->service_registry.BindRemoteServiceProvider(
       std::move(exposed_services));
 }
 
 blink::WebURL ServiceWorkerContextClient::scope() const {
   return service_worker_scope_;
 }
 
+void ServiceWorkerContextClient::getClient(
+    const blink::WebString& id,
+    blink::WebServiceWorkerClientCallbacks* callbacks) {
+  DCHECK(callbacks);
+  int request_id = context_->client_callbacks.Add(callbacks);
+  Send(new ServiceWorkerHostMsg_GetClient(
+      GetRoutingID(), request_id, base::UTF16ToUTF8(base::StringPiece16(id))));
+}
+
 void ServiceWorkerContextClient::getClients(
     const blink::WebServiceWorkerClientQueryOptions& weboptions,
     blink::WebServiceWorkerClientsCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = context_->clients_callbacks.Add(callbacks);
   ServiceWorkerClientQueryOptions options;
   options.client_type = weboptions.clientType;
   options.include_uncontrolled = weboptions.includeUncontrolled;
   Send(new ServiceWorkerHostMsg_GetClients(
       GetRoutingID(), request_id, options));
@@ skipping 554 matching lines @@
           sent_message_ports, new_routing_ids,
           main_thread_task_runner_);
 
   blink::WebCrossOriginServiceWorkerClient web_client;
   web_client.origin = client.origin;
   web_client.targetURL = client.target_url;
   web_client.clientID = client.message_port_id;
   proxy_->dispatchCrossOriginMessageEvent(web_client, message, ports);
 }
 
+void ServiceWorkerContextClient::OnDidGetClient(
+    int request_id,
+    const ServiceWorkerClientInfo& client) {
+  TRACE_EVENT0("ServiceWorker", "ServiceWorkerContextClient::OnDidGetClient");
+  blink::WebServiceWorkerClientCallbacks* callbacks =
+      context_->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(
+        ToWebServiceWorkerClientInfo(client)));
+  }
+  callbacks->onSuccess(blink::adoptWebPtr(web_client.release()));
+  context_->client_callbacks.Remove(request_id);
+}
+
 void ServiceWorkerContextClient::OnDidGetClients(
     int request_id, const std::vector<ServiceWorkerClientInfo>& clients) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnDidGetClients");
   blink::WebServiceWorkerClientsCallbacks* callbacks =
       context_->clients_callbacks.Lookup(request_id);
   if (!callbacks) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
@@ skipping 17 matching lines @@
   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(
         ToWebServiceWorkerClientInfo(client)));
   }
-  callbacks->onSuccess(adoptWebPtr(web_client.release()));
+  callbacks->onSuccess(blink::adoptWebPtr(web_client.release()));
   context_->client_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::OnOpenWindowError(
     int request_id,
     const std::string& message) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnOpenWindowError");
   blink::WebServiceWorkerClientCallbacks* callbacks =
       context_->client_callbacks.Lookup(request_id);
@@ skipping 15 matching lines @@
       context_->client_callbacks.Lookup(request_id);
   if (!callback) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
   if (!client.IsEmpty()) {
     DCHECK(client.IsValid());
     scoped_ptr<blink::WebServiceWorkerClientInfo> web_client (
         new blink::WebServiceWorkerClientInfo(
             ToWebServiceWorkerClientInfo(client)));
-    callback->onSuccess(adoptWebPtr(web_client.release()));
+    callback->onSuccess(blink::adoptWebPtr(web_client.release()));
   } else {
     callback->onError(blink::WebServiceWorkerError(
         blink::WebServiceWorkerError::ErrorTypeNotFound,
         "The WindowClient was not found."));
   }
 
   context_->client_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::OnNavigateClientResponse(
     int request_id,
     const ServiceWorkerClientInfo& client) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnNavigateClientResponse");
   blink::WebServiceWorkerClientCallbacks* callbacks =
       context_->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(
         ToWebServiceWorkerClientInfo(client)));
   }
-  callbacks->onSuccess(adoptWebPtr(web_client.release()));
+  callbacks->onSuccess(blink::adoptWebPtr(web_client.release()));
   context_->client_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::OnNavigateClientError(int request_id,
                                                        const GURL& url) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnNavigateClientError");
   blink::WebServiceWorkerClientCallbacks* callbacks =
       context_->client_callbacks.Lookup(request_id);
   if (!callbacks) {
@@ skipping 54 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content