Revert of 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 25 matching lines @@
 
   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_;
+
+  // |version_| must outlive this callback.
+  ServiceWorkerVersion* version_;
 
   DISALLOW_COPY_AND_ASSIGN(GetClientDocumentsCallback);
 };
 
 namespace {
 
 // Default delay for scheduled stop.
 // (Note that if all references to the version is dropped the worker
 // is also stopped without delay)
 const int64 kStopWorkerDelay = 30;  // 30 secs.
@@ skipping 532 matching lines @@
                                           &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_CrossOriginMessageToWorker(
           client, message, sent_message_port_ids, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   DCHECK(!ContainsKey(controllee_map_, provider_host));
   int controllee_id = controllee_by_id_.Add(provider_host);
-  // IDMap<>'s last index is kInvalidServiceWorkerClientId.
-  CHECK(controllee_id != kInvalidServiceWorkerClientId);
   controllee_map_[provider_host] = controllee_id;
   // Reset the timer if it's running (so that it's kept alive a bit longer
   // right after a new controllee is added).
   ScheduleStopWorker();
 }
 
 void ServiceWorkerVersion::RemoveControllee(
     ServiceWorkerProviderHost* provider_host) {
   ControlleeMap::iterator found = controllee_map_.find(provider_host);
   DCHECK(found != controllee_map_.end());
@@ skipping 90 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()) {
-    // TODO(mlamouri): we could coalesce those requests into one.
-    it.GetCurrentValue()->GetClientInfo(
-        base::Bind(&ServiceWorkerVersion::DidGetClientInfo,
-                   weak_factory_.GetWeakPtr(), it.GetCurrentKey(), callback));
+    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.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 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())
-    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);
+  if (status == SERVICE_WORKER_OK)
+    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