ServiceWorker: Clean up ServiceWorkerVersion::OnGetClients

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 1048 matching lines @@
       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) {
+  TRACE_EVENT_ASYNC_BEGIN2(
+      "ServiceWorker", "ServiceWorkerVersion::OnGetClients", request_id,
+      "client_type", options.client_type, "include_uncontrolled",
+      options.include_uncontrolled);
+
   if (controllee_map_.empty() && !options.include_uncontrolled) {
-    if (running_status() == RUNNING) {
-      embedded_worker_->SendMessage(
-          ServiceWorkerMsg_DidGetClients(request_id,
-              std::vector<ServiceWorkerClientInfo>()));
-    }
+    OnGetClientsFinished(request_id, std::vector<ServiceWorkerClientInfo>());
     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(request_id, options);
     return;
   }
 
   ServiceWorkerClients clients;
   GetNonWindowClients(request_id, options, &clients);
+  OnGetClientsFinished(request_id, clients);
+}
+
+void ServiceWorkerVersion::OnGetClientsFinished(
+    int request_id,
+    const ServiceWorkerClients& clients) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::OnGetClients",
+                         request_id, "The number of clients", clients.size());
+
+  if (running_status() != RUNNING)
+    return;
   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",
@@ skipping 318 matching lines @@
     // possibly due to timing issue or bad message.
     return;
   }
   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 std::string& client_uuid,
     const ServiceWorkerClientInfo& client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (running_status() != RUNNING)
     return;
 
   ServiceWorkerClientInfo client_info(client);
-  client_info.client_uuid = cliend_uuid;
+  client_info.client_uuid = client_uuid;
 
   embedded_worker_->SendMessage(ServiceWorkerMsg_FocusClientResponse(
       request_id, client_info));
 }
 
 void ServiceWorkerVersion::OnSkipWaiting(int request_id) {
   skip_waiting_ = true;
   if (status_ != INSTALLED)
     return DidSkipWaiting(request_id);
 
@@ skipping 79 matching lines @@
         base::Bind(&ServiceWorkerVersion::OnStartSentAndScriptEvaluated,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServiceWorkerVersion::GetWindowClients(
     int request_id,
     const ServiceWorkerClientQueryOptions& options) {
   DCHECK(options.client_type == blink::WebServiceWorkerClientTypeWindow ||
          options.client_type == blink::WebServiceWorkerClientTypeAll);
-  TRACE_EVENT0("ServiceWorker", "ServiceWorkerVersion::GetWindowClients");
-
-  // 4.3.1 matchAll(options)
+  // matchAll(options)

[falken, 2015/04/01 01:39:21]

This looks like commented out code rather than a reference to the spec. I guess
we have to say something like "This implements the spec's matchAll(options)
steps."

[nhiroki, 2015/04/01 03:28:56]

Hmm... I found this method doesn't completely correspond to the
matchAll(options) because this doesn't take care of "client_type == TypeWorker"
etc. OnGetClients() would be more suitable place for the comment.

[nhiroki, 2015/04/01 03:39:56]

Moved.

   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);
     }
@@ skipping 10 matching lines @@
       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));
+  OnGetClientsFinished(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);
     }
@@ skipping 251 matching lines @@
   while (!requests_.empty()) {
     RequestInfo info = requests_.front();
     info.time = ticks;
     new_requests.push(info);
     requests_.pop();
   }
   requests_ = new_requests;
 }
 
 }  // namespace content