Service Worker: Add Clients.get(id)

content/browser/service_worker/service_worker_client_utils.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/browser/service_worker/service_worker_client_utils.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "content/browser/frame_host/frame_tree_node.h"
@@ skipping 158 matching lines @@
 }
 
 void DidNavigate(const base::WeakPtr<ServiceWorkerContextCore>& context,
                  const GURL& origin,
                  const NavigationCallback& callback,
                  int render_process_id,
                  int render_frame_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!context) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT, std::string(),
-                 ServiceWorkerClientInfo());
+    callback.Run(SERVICE_WORKER_ERROR_ABORT, ServiceWorkerClientInfo());
     return;
   }
 
   if (render_process_id == ChildProcessHost::kInvalidUniqueID &&
       render_frame_id == MSG_ROUTING_NONE) {
-    callback.Run(SERVICE_WORKER_ERROR_FAILED, std::string(),
-                 ServiceWorkerClientInfo());
+    callback.Run(SERVICE_WORKER_ERROR_FAILED, ServiceWorkerClientInfo());
     return;
   }
 
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context->GetClientProviderHostIterator(origin);
        !it->IsAtEnd(); it->Advance()) {
     ServiceWorkerProviderHost* provider_host = it->GetProviderHost();
     if (provider_host->process_id() != render_process_id ||
         provider_host->frame_id() != render_frame_id) {
       continue;
     }
-    provider_host->GetWindowClientInfo(
-        base::Bind(callback, SERVICE_WORKER_OK, provider_host->client_uuid()));
+    provider_host->GetWindowClientInfo(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
 
   // If here, it means that no provider_host was found, in which case, the
   // renderer should still be informed that the window was opened.
-  callback.Run(SERVICE_WORKER_OK, std::string(), ServiceWorkerClientInfo());
+  callback.Run(SERVICE_WORKER_OK, ServiceWorkerClientInfo());
 }
 
 void AddWindowClient(
     ServiceWorkerProviderHost* host,
     std::vector<base::Tuple<int, int, std::string>>* client_info) {
   if (host->client_type() != blink::WebServiceWorkerClientTypeWindow)
     return;
   client_info->push_back(base::MakeTuple(host->process_id(), host->frame_id(),
                                          host->client_uuid()));
 }
 
 void AddNonWindowClient(ServiceWorkerProviderHost* host,
                         const ServiceWorkerClientQueryOptions& options,
                         ServiceWorkerClients* clients) {
   blink::WebServiceWorkerClientType host_client_type = host->client_type();
   if (host_client_type == blink::WebServiceWorkerClientTypeWindow)
     return;
   if (options.client_type != blink::WebServiceWorkerClientTypeAll &&
       options.client_type != host_client_type)
     return;
 
-  ServiceWorkerClientInfo client_info(blink::WebPageVisibilityStateHidden,
-                                      false,  // is_focused
-                                      host->document_url(),
-                                      REQUEST_CONTEXT_FRAME_TYPE_NONE,
-                                      base::TimeTicks(), host_client_type);
-  client_info.client_uuid = host->client_uuid();
+  ServiceWorkerClientInfo client_info(
+      host->client_uuid(), blink::WebPageVisibilityStateHidden,
+      false,  // is_focused
+      host->document_url(), REQUEST_CONTEXT_FRAME_TYPE_NONE, base::TimeTicks(),
+      host_client_type);
   clients->push_back(client_info);
 }
 
 void OnGetWindowClientsOnUI(
     // The tuple contains process_id, frame_id, client_uuid.
     const std::vector<base::Tuple<int, int, std::string>>& clients_info,
     const GURL& script_url,
     const GetWindowClientsCallback& callback) {
   scoped_ptr<ServiceWorkerClients> clients(new ServiceWorkerClients);
 
   for (const auto& it : clients_info) {
     ServiceWorkerClientInfo info =
-        ServiceWorkerProviderHost::GetWindowClientInfoOnUI(base::get<0>(it),
-                                                           base::get<1>(it));
+        ServiceWorkerProviderHost::GetWindowClientInfoOnUI(
+            base::get<0>(it), base::get<1>(it), base::get<2>(it));
 
     // If the request to the provider_host returned an empty
     // ServiceWorkerClientInfo, that means that it wasn't possible to associate
     // it with a valid RenderFrameHost. It might be because the frame was killed
     // or navigated in between.
     if (info.IsEmpty())
       continue;
 
     // We can get info for a frame that was navigating end ended up with a
     // different URL than expected. In such case, we should make sure to not
     // expose cross-origin WindowClient.
     if (info.url.GetOrigin() != script_url.GetOrigin())
       continue;
 
-    info.client_uuid = base::get<2>(it);
     clients->push_back(info);
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, base::Passed(&clients)));
 }
 
 struct ServiceWorkerClientInfoSortMRU {
   bool operator()(const ServiceWorkerClientInfo& a,
                   const ServiceWorkerClientInfo& b) const {
@@ skipping 91 matching lines @@
                     const base::WeakPtr<ServiceWorkerContextCore>& context,
                     const NavigationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &NavigateClientOnUI, url, script_url, process_id, frame_id,
           base::Bind(&DidNavigate, context, script_url.GetOrigin(), callback)));
 }
 
+void GetClient(
+    const base::WeakPtr<ServiceWorkerVersion>& controller,
+    const std::string& client_uuid,
+    const base::WeakPtr<ServiceWorkerContextCore>& context,
+    const ServiceWorkerProviderHost::GetClientInfoCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  ServiceWorkerProviderHost* provider_host =
+      context->GetProviderHostByClientID(client_uuid);
+
+  if (!provider_host) {
+    // The client may already have been closed, just ignore.
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, ServiceWorkerClientInfo()));
+    return;
+  }
+
+  if (provider_host->document_url().GetOrigin() !=
+      controller->script_url().GetOrigin()) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, ServiceWorkerClientInfo()));
+    return;
+  }
+
+  if (provider_host->client_type() == blink::WebServiceWorkerClientTypeWindow) {
+    provider_host->GetWindowClientInfo(callback);
+    return;
+  }
+
+  DCHECK(provider_host->client_type() ==
+             blink::WebServiceWorkerClientTypeWorker ||
+         provider_host->client_type() ==
+             blink::WebServiceWorkerClientTypeSharedWorker);
+
+  ServiceWorkerClientInfo client_info(
+      provider_host->client_uuid(), blink::WebPageVisibilityStateHidden,
+      false,  // is_focused
+      provider_host->document_url(), REQUEST_CONTEXT_FRAME_TYPE_NONE,
+      base::TimeTicks(), provider_host->client_type());
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(callback, client_info));
+}
+
 void GetClients(const base::WeakPtr<ServiceWorkerVersion>& controller,
                 const ServiceWorkerClientQueryOptions& options,
                 const ClientsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ServiceWorkerClients clients;
   if (!controller->HasControllee() && !options.include_uncontrolled) {
     DidGetClients(callback, &clients);
     return;
   }
 
   // For Window clients we want to query the info on the UI thread first.
   if (options.client_type == blink::WebServiceWorkerClientTypeWindow ||
       options.client_type == blink::WebServiceWorkerClientTypeAll) {
     GetWindowClients(controller, options, callback);
     return;
   }
 
   GetNonWindowClients(controller, options, &clients);
   DidGetClients(callback, &clients);
 }
 
 }  // namespace service_worker_client_utils
 }  // namespace content