Gather the ServiceWorker client information in the browser process.

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/stl_util.h"
 #include "base/strings/string16.h"
@@ skipping 18 matching lines @@
  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;
+    clients_.back().SetClientID(client_id);
   }
 
  private:
   friend class base::RefCounted<GetClientDocumentsCallback>;
 
   virtual ~GetClientDocumentsCallback() {
     if (version_->running_status() == RUNNING) {
       version_->embedded_worker_->SendMessage(
           ServiceWorkerMsg_DidGetClientDocuments(request_id_, clients_));
     }
@@ skipping 659 matching lines @@
                     SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
                     ServiceWorkerResponse());
   RunIDMapCallbacks(&sync_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&notification_click_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&push_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&geofencing_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
-  RunIDMapCallbacks(&get_client_info_callbacks_,
-                    SERVICE_WORKER_ERROR_FAILED,
-                    ServiceWorkerClientInfo());
   RunIDMapCallbacks(&cross_origin_connect_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED,
                     false);
 
   streaming_url_request_jobs_.clear();
 
   FOR_EACH_OBSERVER(Listener, listeners_, OnWorkerStopped(this));
 
   // There should be no more communication from/to a stopped worker. Deleting
   // the listener prevents any pending completion callbacks from causing
@@ skipping 55 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PushEventFinished,
                         OnPushEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GeofencingEventFinished,
                         OnGeofencingEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CrossOriginConnectEventFinished,
                         OnCrossOriginConnectEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToDocument,
                         OnPostMessageToDocument)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FocusClient,
                         OnFocusClient)
-    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetClientInfoSuccess,
-                        OnGetClientInfoSuccess)
-    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetClientInfoError,
-                        OnGetClientInfoError)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SkipWaiting,
                         OnSkipWaiting)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartMessageSent(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK)
@@ skipping 37 matching lines @@
               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()) {
-    int client_request_id = get_client_info_callbacks_.Add(
-        new GetClientInfoCallback(base::Bind(
-            &ServiceWorkerVersion::DidGetClientInfo,
-            weak_factory_.GetWeakPtr(), it.GetCurrentKey(), callback)));
-    it.GetCurrentValue()->GetClientInfo(embedded_worker_->embedded_worker_id(),
-                                        client_request_id);
+    it.GetCurrentValue()->GetClientInfo(
+        base::Bind(&ServiceWorkerVersion::DidGetClientInfo,
+                   weak_factory_.GetWeakPtr(), it.GetCurrentKey(), callback));
     it.Advance();
   }
 }
 
-void ServiceWorkerVersion::OnGetClientInfoSuccess(
-    int request_id,
-    const ServiceWorkerClientInfo& info) {
-  GetClientInfoCallback* callback =
-      get_client_info_callbacks_.Lookup(request_id);
-  if (!callback) {
-    // The callback may already have been cleared by OnStopped, just ignore.
-    return;
-  }
-  callback->Run(SERVICE_WORKER_OK, info);
-  RemoveCallbackAndStopIfDoomed(&get_client_info_callbacks_, request_id);
-}
-
-void ServiceWorkerVersion::OnGetClientInfoError(int request_id) {
-  GetClientInfoCallback* callback =
-      get_client_info_callbacks_.Lookup(request_id);
-  if (!callback) {
-    // The callback may already have been cleared by OnStopped, just ignore.
-    return;
-  }
-  callback->Run(SERVICE_WORKER_ERROR_FAILED, ServiceWorkerClientInfo());
-  RemoveCallbackAndStopIfDoomed(&get_client_info_callbacks_, request_id);
-}
-
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
   DCHECK(ACTIVATING == status() ||
          REDUNDANT == status()) << status();
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnActivateEventFinished");
 
   StatusCallback* callback = activate_callbacks_.Lookup(request_id);
   if (!callback) {
@@ skipping 199 matching lines @@
 }
 
 void ServiceWorkerVersion::DidSkipWaiting(int request_id) {
   if (running_status() == STARTING || running_status() == RUNNING)
     embedded_worker_->SendMessage(ServiceWorkerMsg_DidSkipWaiting(request_id));
 }
 
 void ServiceWorkerVersion::DidGetClientInfo(
     int client_id,
     scoped_refptr<GetClientDocumentsCallback> callback,
-    ServiceWorkerStatusCode status,
     const ServiceWorkerClientInfo& info) {
-  if (status == SERVICE_WORKER_OK)
-    callback->AddClientInfo(client_id, info);
+  DCHECK(!info.IsEmpty());
+  callback->AddClientInfo(client_id, info);
 }
 
 void ServiceWorkerVersion::ScheduleStopWorker() {
   if (running_status() != RUNNING)
     return;
   stop_worker_timer_.Stop();
   stop_worker_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(
           is_doomed_ ? kStopDoomedWorkerDelay : kStopWorkerDelay),
       base::Bind(&ServiceWorkerVersion::StopWorkerIfIdle,
@@ skipping 17 matching lines @@
 
 bool ServiceWorkerVersion::HasInflightRequests() const {
   return
     !activate_callbacks_.IsEmpty() ||
     !install_callbacks_.IsEmpty() ||
     !fetch_callbacks_.IsEmpty() ||
     !sync_callbacks_.IsEmpty() ||
     !notification_click_callbacks_.IsEmpty() ||
     !push_callbacks_.IsEmpty() ||
     !geofencing_callbacks_.IsEmpty() ||
-    !get_client_info_callbacks_.IsEmpty() ||
     !cross_origin_connect_callbacks_.IsEmpty() ||
     !streaming_url_request_jobs_.empty();
 }
 
 void ServiceWorkerVersion::DoomInternal() {
   DCHECK(is_doomed_);
   DCHECK(!HasControllee());
   SetStatus(REDUNDANT);
   StopWorkerIfIdle();
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
 template <typename IDMAP>
 void ServiceWorkerVersion::RemoveCallbackAndStopIfDoomed(
     IDMAP* callbacks,
     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