ServiceWorker: coalesce all SWClientInfo request into one task.

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 19 matching lines @@
 #include "content/public/browser/web_contents.h"
 #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 {
 
-typedef ServiceWorkerVersion::StatusCallback StatusCallback;
-
-class ServiceWorkerVersion::GetClientDocumentsCallback
-    : public base::RefCounted<GetClientDocumentsCallback> {
- public:
-  GetClientDocumentsCallback(int request_id,
-                             ServiceWorkerVersion* version)
-      : request_id_(request_id),
-        version_(version) {
-    DCHECK(version_);
-  }
-
-  void AddClientInfo(int client_id, const ServiceWorkerClientInfo& info) {
-    clients_.push_back(info);
-    clients_.back().client_id = client_id;
-  }
-
- private:
-  friend class base::RefCounted<GetClientDocumentsCallback>;
-
-  virtual ~GetClientDocumentsCallback() {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-    if (version_->running_status() == RUNNING) {
-      version_->embedded_worker_->SendMessage(
-          ServiceWorkerMsg_DidGetClientDocuments(request_id_, clients_));
-    }
-  }
-
-  std::vector<ServiceWorkerClientInfo> clients_;
-  int request_id_;
-  scoped_refptr<ServiceWorkerVersion> version_;
-
-  DISALLOW_COPY_AND_ASSIGN(GetClientDocumentsCallback);
-};
+using StatusCallback = ServiceWorkerVersion::StatusCallback;
+using GetClientDocumentsCallback =
+    base::Callback<void(const std::vector<ServiceWorkerClientInfo>&)>;
 
 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 194 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 OnGetClientDocumentsFromUI(
+    // The tuple contains process_id, frame_id, client_id.

[michaeln, 2015/03/06 23:55:22]

nice comment

+    const std::vector<Tuple<int,int,int>>& clients_info,
+    const GURL& script_url,
+    const GetClientDocumentsCallback& callback) {
+  std::vector<ServiceWorkerClientInfo> clients;
+
+  for (const auto& it : clients_info) {
+    ServiceWorkerClientInfo info =
+        ServiceWorkerProviderHost::GetClientInfoOnUI(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;
+
+    info.client_id = get<2>(it);
+    clients.push_back(info);
+  }
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(callback, clients));
+}
+
 }  // namespace
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     const GURL& script_url,
     int64 version_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : version_id_(version_id),
       registration_id_(kInvalidServiceWorkerVersionId),
       script_url_(script_url),
@@ skipping 687 matching lines @@
 
 void ServiceWorkerVersion::OnGetClientDocuments(int request_id) {
   if (controllee_by_id_.IsEmpty()) {
     if (running_status() == RUNNING) {
       embedded_worker_->SendMessage(
           ServiceWorkerMsg_DidGetClientDocuments(request_id,
               std::vector<ServiceWorkerClientInfo>()));
     }
     return;
   }
-  scoped_refptr<GetClientDocumentsCallback> callback(
-      new GetClientDocumentsCallback(request_id, this));
-  ControlleeByIDMap::iterator it(&controllee_by_id_);
+
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnGetClientDocuments");
-  while (!it.IsAtEnd()) {
-    // TODO(mlamouri): we could coalesce those requests into one.
-    it.GetCurrentValue()->GetClientInfo(
-        base::Bind(&ServiceWorkerVersion::DidGetClientInfo,
-                   weak_factory_.GetWeakPtr(), it.GetCurrentKey(), callback));
-    it.Advance();
+
+  std::vector<Tuple<int,int,int>> clients_info;
+  for (ControlleeByIDMap::iterator it(&controllee_by_id_); !it.IsAtEnd();
+       it.Advance()) {
+    int process_id = it.GetCurrentValue()->process_id();
+    int frame_id = it.GetCurrentValue()->frame_id();
+    int client_id = it.GetCurrentKey();
+
+    clients_info.push_back(MakeTuple(process_id, frame_id, client_id));
   }
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&OnGetClientDocumentsFromUI, clients_info, script_url_,
+                 base::Bind(&ServiceWorkerVersion::DidGetClientDocuments,
+                            weak_factory_.GetWeakPtr(),
+                            request_id)));
+
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
   DCHECK(ACTIVATING == status() ||
          REDUNDANT == status()) << status();
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnActivateEventFinished");
 
@@ skipping 372 matching lines @@
   if (status == SERVICE_WORKER_ERROR_ABORT) {
     embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
         request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
         base::ASCIIToUTF16(kClaimClientsShutdownErrorMesage)));
     return;
   }
   DCHECK(status == SERVICE_WORKER_OK);
   embedded_worker_->SendMessage(ServiceWorkerMsg_DidClaimClients(request_id));
 }
 
-void ServiceWorkerVersion::DidGetClientInfo(
-    int client_id,
-    scoped_refptr<GetClientDocumentsCallback> callback,
-    const ServiceWorkerClientInfo& info) {
-  // 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())
+void ServiceWorkerVersion::DidGetClientDocuments(
+    int request_id,
+    const std::vector<ServiceWorkerClientInfo>& clients) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (running_status() != RUNNING)
     return;
 
-  // 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;
-
-  callback->AddClientInfo(client_id, info);
+  embedded_worker_->SendMessage(
+      ServiceWorkerMsg_DidGetClientDocuments(request_id, clients));
 }
 
 void ServiceWorkerVersion::StartTimeoutTimer() {
   DCHECK(!timeout_timer_.IsRunning());
   ClearTick(&idle_time_);
   ClearTick(&ping_time_);
   ping_timed_out_ = false;
   timeout_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromSeconds(kTimeoutTimerDelaySeconds),
                        this, &ServiceWorkerVersion::OnTimeoutTimer);
@@ skipping 155 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