Reland: ServiceWorker: Support includeUncontrolled option 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 973 matching lines @@
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_ActivateEvent(request_id));
   if (status != SERVICE_WORKER_OK) {
     activate_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::OnGetClients(
     int request_id,
-    const ServiceWorkerClientQueryOptions& /* options */) {
-  // TODO(kinuko): Handle ClientQueryOptions. (crbug.com/455241, 460415 etc)
-  if (controllee_map_.empty()) {
+    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;
-  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));
+  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()));
+    }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&OnGetClientsFromUI, clients_info, script_url_,
                  base::Bind(&ServiceWorkerVersion::DidGetClients,
                             weak_factory_.GetWeakPtr(),
                             request_id)));
 
 }
@@ skipping 199 matching lines @@
   if (running_status() != RUNNING)
     return;
 
   if (render_process_id == ChildProcessHost::kInvalidUniqueID &&
       render_frame_id == MSG_ROUTING_NONE) {
     embedded_worker_->SendMessage(ServiceWorkerMsg_OpenWindowError(
         request_id, "Something went wrong while trying to open the window."));
     return;
   }
 
-  for (const auto& it : controllee_map_) {
-    const ServiceWorkerProviderHost* provider_host = it.second;
+  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;
     }
-
-    // it.second is the client_uuid associated with the provider_host.
-    provider_host->GetClientInfo(
-        base::Bind(&ServiceWorkerVersion::OnOpenWindowFinished,
-                   weak_factory_.GetWeakPtr(), request_id, it.first));
+    provider_host->GetClientInfo(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());
 }
 
 void ServiceWorkerVersion::OnOpenWindowFinished(
     int request_id,
@@ skipping 50 matching lines @@
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerVersion::OnClearCachedMetadata",
                          callback_id, "result", result);
   FOR_EACH_OBSERVER(Listener, listeners_, OnCachedMetadataUpdated(this));
 }
 
 void ServiceWorkerVersion::OnPostMessageToClient(
     const std::string& client_uuid,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports) {
+  if (!context_)
+    return;
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerVersion::OnPostMessageToDocument",
                "Client id", client_uuid);
-  auto it = controllee_map_.find(client_uuid);
-  if (it == controllee_map_.end()) {
+  ServiceWorkerProviderHost* provider_host =
+      context_->GetProviderHostByClientID(client_uuid);
+  if (!provider_host) {
     // The client may already have been closed, just ignore.
     return;
   }
-  if (it->second->document_url().GetOrigin() != script_url_.GetOrigin()) {
+  if (provider_host->document_url().GetOrigin() != script_url_.GetOrigin()) {
     // The client does not belong to the same origin as this ServiceWorker,
     // possibly due to timing issue or bad message.
     return;
   }
-  it->second->PostMessage(message, sent_message_ports);
+  provider_host->PostMessage(message, sent_message_ports);
 }
 
 void ServiceWorkerVersion::OnFocusClient(int request_id,
                                          const std::string& client_uuid) {
+  if (!context_)
+    return;
   TRACE_EVENT2("ServiceWorker",
                "ServiceWorkerVersion::OnFocusClient",
                "Request id", request_id,
                "Client id", client_uuid);
-  auto it = controllee_map_.find(client_uuid);
-  if (it == controllee_map_.end()) {
+  ServiceWorkerProviderHost* provider_host =
+      context_->GetProviderHostByClientID(client_uuid);
+  if (!provider_host) {
     // The client may already have been closed, just ignore.
     return;
   }
-  if (it->second->document_url().GetOrigin() != script_url_.GetOrigin()) {
+  if (provider_host->document_url().GetOrigin() != script_url_.GetOrigin()) {
     // The client does not belong to the same origin as this ServiceWorker,
     // possibly due to timing issue or bad message.
     return;
   }
-
-  it->second->Focus(
-      base::Bind(&ServiceWorkerVersion::OnFocusClientFinished,
-                 weak_factory_.GetWeakPtr(),
-                 request_id,
-                 client_uuid));
+  provider_host->Focus(base::Bind(&ServiceWorkerVersion::OnFocusClientFinished,
+                                  weak_factory_.GetWeakPtr(), request_id,
+                                  client_uuid));
 }
 
 void ServiceWorkerVersion::OnFocusClientFinished(
     int request_id,
     const std::string& cliend_uuid,
     const ServiceWorkerClientInfo& client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (running_status() != RUNNING)
     return;
@@ skipping 300 matching lines @@
     int request_id) {
   callbacks->Remove(request_id);
   if (is_doomed_) {
     // The stop should be already scheduled, but try to stop immediately, in
     // order to release worker resources soon.
     StopWorkerIfIdle();
   }
 }
 
 }  // namespace content