ServiceWorker: Support non-window clients in Clients.matchAll (1/2 chromium)

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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_version.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "net/http/http_response_info.h"
 
 namespace content {
 
 using StatusCallback = ServiceWorkerVersion::StatusCallback;
+using ServiceWorkerClients = std::vector<ServiceWorkerClientInfo>;
 using GetClientsCallback =
-    base::Callback<void(const std::vector<ServiceWorkerClientInfo>&)>;
+    base::Callback<void(scoped_ptr<ServiceWorkerClients>)>;
 
 namespace {
 
 // Delay between the timeout timer firing.
 const int kTimeoutTimerDelaySeconds = 30;
 
 // Time to wait until stopping an idle worker.
 const int kIdleWorkerTimeoutSeconds = 30;
 
 // Default delay for scheduled update.
@@ skipping 221 matching lines @@
 void RestartTick(base::TimeTicks* time) {
   *time = base::TimeTicks().Now();
 }
 
 base::TimeDelta GetTickDuration(const base::TimeTicks& time) {
   if (time.is_null())
     return base::TimeDelta();
   return base::TimeTicks().Now() - time;
 }
 
-void OnGetClientsFromUI(
+void OnGetWindowClientsFromUI(
     // The tuple contains process_id, frame_id, client_uuid.
-    const std::vector<Tuple<int,int,std::string>>& clients_info,
+    const std::vector<Tuple<int, int, std::string>>& clients_info,
     const GURL& script_url,
     const GetClientsCallback& callback) {
-  std::vector<ServiceWorkerClientInfo> clients;
+  scoped_ptr<ServiceWorkerClients> clients(new ServiceWorkerClients);
 
   for (const auto& it : clients_info) {
     ServiceWorkerClientInfo info =
-        ServiceWorkerProviderHost::GetClientInfoOnUI(get<0>(it), get<1>(it));
+        ServiceWorkerProviderHost::GetWindowClientInfoOnUI(get<0>(it),
+                                                           get<1>(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())
-      return;
+      continue;

[nhiroki, 2015/03/31 05:26:33]

Oh... |callback| was gone... good catch!

 
     info.client_uuid = get<2>(it);
-    clients.push_back(info);
+    clients->push_back(info);
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(callback, clients));
+                          base::Bind(callback, base::Passed(&clients)));
+}
+
+void AddWindowClient(ServiceWorkerProviderHost* host,
+                     std::vector<Tuple<int, int, std::string>>* client_info) {
+  if (host->client_type() != blink::WebServiceWorkerClientTypeWindow)
+    return;
+  client_info->push_back(
+      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, host_client_type);
+  client_info.client_uuid = host->client_uuid();
+  clients->push_back(client_info);
 }
 
 }  // namespace
 
 const int ServiceWorkerVersion::kStartWorkerTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     const GURL& script_url,
@@ skipping 705 matching lines @@
     const ServiceWorkerClientQueryOptions& options) {
   if (controllee_map_.empty() && !options.include_uncontrolled) {
     if (running_status() == RUNNING) {
       embedded_worker_->SendMessage(
           ServiceWorkerMsg_DidGetClients(request_id,
               std::vector<ServiceWorkerClientInfo>()));
     }
     return;
   }
 
-  TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerVersion::OnGetClients");
-
-  // 4.3.1 matchAll(options)
-  std::vector<Tuple<int,int,std::string>> clients_info;
-  if (!options.include_uncontrolled) {
-    for (auto& controllee : controllee_map_) {
-      int process_id = controllee.second->process_id();
-      int frame_id = controllee.second->frame_id();
-      const std::string& client_uuid = controllee.first;
-      clients_info.push_back(MakeTuple(process_id, frame_id, client_uuid));
-    }
-  } else {
-    for (auto it =
-             context_->GetClientProviderHostIterator(script_url_.GetOrigin());
-         !it->IsAtEnd(); it->Advance()) {
-      ServiceWorkerProviderHost* host = it->GetProviderHost();
-      clients_info.push_back(
-          MakeTuple(host->process_id(), host->frame_id(), host->client_uuid()));
-    }
+  // 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(request_id, options);
+    return;
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&OnGetClientsFromUI, clients_info, script_url_,
-                 base::Bind(&ServiceWorkerVersion::DidGetClients,
-                            weak_factory_.GetWeakPtr(),
-                            request_id)));
-
+  ServiceWorkerClients clients;
+  GetNonWindowClients(request_id, options, &clients);
+  embedded_worker_->SendMessage(
+      ServiceWorkerMsg_DidGetClients(request_id, clients));
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
   DCHECK(ACTIVATING == status() ||
          REDUNDANT == status()) << status();
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnActivateEventFinished");
 
@@ skipping 198 matching lines @@
   }
 
   for (auto it =
            context_->GetClientProviderHostIterator(script_url_.GetOrigin());
        !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->GetClientInfo(base::Bind(
+    provider_host->GetWindowClientInfo(base::Bind(
         &ServiceWorkerVersion::OnOpenWindowFinished, weak_factory_.GetWeakPtr(),
         request_id, provider_host->client_uuid()));
     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.
   OnOpenWindowFinished(request_id, std::string(), ServiceWorkerClientInfo());
 }
 
@@ skipping 200 matching lines @@
   if (!timeout_timer_.IsRunning())
     StartTimeoutTimer();
   if (running_status() == STOPPED) {
     embedded_worker_->Start(
         version_id_, scope_, script_url_, pause_after_download,
         base::Bind(&ServiceWorkerVersion::OnStartSentAndScriptEvaluated,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
-void ServiceWorkerVersion::DidGetClients(
+void ServiceWorkerVersion::GetWindowClients(
     int request_id,
-    const std::vector<ServiceWorkerClientInfo>& clients) {
+    const ServiceWorkerClientQueryOptions& options) {
+  DCHECK(options.client_type == blink::WebServiceWorkerClientTypeWindow ||
+         options.client_type == blink::WebServiceWorkerClientTypeAll);
+  TRACE_EVENT0("ServiceWorker", "ServiceWorkerVersion::GetWindowClients");

[falken, 2015/03/31 03:39:48]

Should this trace span to DidGetWindowClients?

[nhiroki, 2015/04/01 00:50:53]

Done in https://codereview.chromium.org/1050733002/

+
+  // 4.3.1 matchAll(options)

[falken, 2015/03/31 03:39:48]

FYI I've given up on putting spec section numbers since they get stale really
fast.

[nhiroki, 2015/04/01 00:50:53]

Done in https://codereview.chromium.org/1050733002/

+  std::vector<Tuple<int, int, std::string>> clients_info;
+  if (!options.include_uncontrolled) {
+    for (auto& controllee : controllee_map_)
+      AddWindowClient(controllee.second, &clients_info);
+  } else {
+    for (auto it =
+             context_->GetClientProviderHostIterator(script_url_.GetOrigin());
+         !it->IsAtEnd(); it->Advance()) {
+      AddWindowClient(it->GetProviderHost(), &clients_info);
+    }
+  }
+
+  if (clients_info.empty()) {
+    DidGetWindowClients(request_id, options,
+                        make_scoped_ptr(new ServiceWorkerClients));
+    return;
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&OnGetWindowClientsFromUI, clients_info, script_url_,
+                 base::Bind(&ServiceWorkerVersion::DidGetWindowClients,
+                            weak_factory_.GetWeakPtr(), request_id, options)));
+}
+
+void ServiceWorkerVersion::DidGetWindowClients(
+    int request_id,
+    const ServiceWorkerClientQueryOptions& options,
+    scoped_ptr<ServiceWorkerClients> clients) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (running_status() != RUNNING)
     return;
 
+  if (options.client_type == blink::WebServiceWorkerClientTypeAll)
+    GetNonWindowClients(request_id, options, clients.get());
+
   embedded_worker_->SendMessage(
-      ServiceWorkerMsg_DidGetClients(request_id, clients));
+      ServiceWorkerMsg_DidGetClients(request_id, *clients));
+}
+
+void ServiceWorkerVersion::GetNonWindowClients(
+    int request_id,
+    const ServiceWorkerClientQueryOptions& options,
+    ServiceWorkerClients* clients) {
+  if (!options.include_uncontrolled) {
+    for (auto& controllee : controllee_map_) {
+      AddNonWindowClient(controllee.second, options, clients);
+    }
+  } else {
+    for (auto it =
+             context_->GetClientProviderHostIterator(script_url_.GetOrigin());
+         !it->IsAtEnd(); it->Advance()) {
+      AddNonWindowClient(it->GetProviderHost(), options, clients);
+    }
+  }
 }
 
 void ServiceWorkerVersion::StartTimeoutTimer() {
   DCHECK(!timeout_timer_.IsRunning());
 
   if (embedded_worker_->devtools_attached()) {
     // Don't record the startup time metric once DevTools is attached.
     ClearTick(&start_time_);
     skip_recording_startup_time_ = true;
   } else {
@@ skipping 234 matching lines @@
   while (!requests_.empty()) {
     RequestInfo info = requests_.front();
     info.time = ticks;
     new_requests.push(info);
     requests_.pop();
   }
   requests_ = new_requests;
 }
 
 }  // namespace content