Implement ServiceWorkerClient attributes [2/3]

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/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 
 namespace content {
 
 typedef ServiceWorkerVersion::StatusCallback StatusCallback;
 typedef ServiceWorkerVersion::MessageCallback MessageCallback;
 
+class ServiceWorkerVersion::GetClientInfoCallback {
+ public:
+  GetClientInfoCallback(int request_id)
+    : request_id_(request_id) {}
+  void add(int client_request_id, int client_id) {

[nhiroki, 2014/12/08 05:45:09]

The first letter of function names should be capitalized.

[Kunihiko Sakamoto, 2014/12/08 06:43:18]

Done.

+    pending_requests_[client_request_id] = client_id;
+  }
+  void success(int client_request_id, const ServiceWorkerClientInfo& info) {
+    auto found = pending_requests_.find(client_request_id);
+    DCHECK(found != pending_requests_.end());
+    clients_.push_back(info);
+    clients_.back().client_id = found->second;
+    pending_requests_.erase(found);
+  }
+  void error(int client_request_id) { cancel(client_request_id); }
+  void cancel(int client_request_id) {
+    auto found = pending_requests_.find(client_request_id);
+    DCHECK(found != pending_requests_.end());
+    pending_requests_.erase(found);
+  }
+  int request_id() { return request_id_; }
+  bool has_pending_requests() { return !pending_requests_.empty(); }
+  const std::vector<ServiceWorkerClientInfo>& clients() { return clients_; }
+
+  static void ClearCallbacks(IDMap<GetClientInfoCallback>* callbacks);
+
+ private:
+  std::vector<ServiceWorkerClientInfo> clients_;
+  int request_id_;
+  std::map<int, int> pending_requests_;
+};
+
 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.
 
 // Default delay for scheduled update.
 const int kUpdateDelaySeconds = 1;
 
@@ skipping 534 matching lines @@
                     SERVICE_WORKER_ERROR_FAILED,
                     SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
                     ServiceWorkerResponse());
   RunIDMapCallbacks(&sync_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&push_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&geofencing_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
 
+  GetClientInfoCallback::ClearCallbacks(&get_client_info_callbacks_);
+
   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
   // messages to be sent to the stopped worker.
   cache_listener_.reset();
 
   // Restart worker if we have any start callbacks and the worker isn't doomed.
   if (should_restart) {
     cache_listener_.reset(new ServiceWorkerCacheListener(this, context_));
@@ skipping 47 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationClickEventFinished,
                         OnNotificationClickEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PushEventFinished,
                         OnPushEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GeofencingEventFinished,
                         OnGeofencingEventFinished)
     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_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartMessageSent(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK)
     RunCallbacks(this, &start_callbacks_, status);
 }
@@ skipping 21 matching lines @@
   int request_id = activate_callbacks_.Add(new StatusCallback(callback));
   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::OnGetClientDocuments(int request_id) {
-  std::vector<int> client_ids;
+  if (controllee_by_id_.IsEmpty()) {
+    if (running_status() == RUNNING) {
+      embedded_worker_->SendMessage(
+          ServiceWorkerMsg_DidGetClientDocuments(request_id,
+              std::vector<ServiceWorkerClientInfo>()));
+    }
+    return;
+  }
+  GetClientInfoCallback* callback = new GetClientInfoCallback(request_id);
   ControlleeByIDMap::iterator it(&controllee_by_id_);
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnGetClientDocuments");
   while (!it.IsAtEnd()) {
-    client_ids.push_back(it.GetCurrentKey());
+    int client_request_id = get_client_info_callbacks_.Add(callback);
+    callback->add(client_request_id, it.GetCurrentKey());
+    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) {
+    NOTREACHED() << "Got unexpected message: " << request_id;
+    return;
+  }
+  get_client_info_callbacks_.Remove(request_id);
+
+  callback->success(request_id, info);
+  if (callback->has_pending_requests())
+    return;
+
   // Don't bother if it's no longer running.
   if (running_status() == RUNNING) {
     embedded_worker_->SendMessage(
-        ServiceWorkerMsg_DidGetClientDocuments(request_id, client_ids));
+        ServiceWorkerMsg_DidGetClientDocuments(callback->request_id(),
+                                               callback->clients()));
   }
+  delete callback;
+}
+
+void ServiceWorkerVersion::OnGetClientInfoError(int request_id) {
+  GetClientInfoCallback* callback =
+      get_client_info_callbacks_.Lookup(request_id);
+  if (!callback) {
+    NOTREACHED() << "Got unexpected message: " << request_id;
+    return;
+  }
+  get_client_info_callbacks_.Remove(request_id);
+
+  callback->error(request_id);
+  if (callback->has_pending_requests())
+    return;
+
+  // Don't bother if it's no longer running.
+  if (running_status() == RUNNING) {
+    embedded_worker_->SendMessage(
+        ServiceWorkerMsg_DidGetClientDocuments(callback->request_id(),
+                                               callback->clients()));
+  }
+  delete callback;
 }
 
 void ServiceWorkerVersion::OnActivateEventFinished(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
   DCHECK(ACTIVATING == status() ||
          REDUNDANT == status()) << status();
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerVersion::OnActivateEventFinished");
 
@@ skipping 182 matching lines @@
   DCHECK(!HasControllee());
   SetStatus(REDUNDANT);
   StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
+void ServiceWorkerVersion::GetClientInfoCallback::ClearCallbacks(
+    IDMap<GetClientInfoCallback>* callbacks) {
+  IDMap<GetClientInfoCallback>::iterator iter(callbacks);
+  while (!iter.IsAtEnd()) {
+    GetClientInfoCallback* callback = iter.GetCurrentValue();
+    callback->cancel(iter.GetCurrentKey());
+    if (!callback->has_pending_requests())

[nhiroki, 2014/12/08 05:45:08]

This condition seems never fulfilled because only callbacks whose
|has_pending_requests()| is greater than 0 should be in
|get_client_info_callbacks|.

Did you mean "if (callback->has_pending_requests()) delete callback;"?

[nhiroki, 2014/12/08 05:47:05]

CORRECTION: |has_pending_requests()| is **true**
 

[Kunihiko Sakamoto, 2014/12/08 06:43:18]

callback->Cancel() above decrements pending_requests_.size() by 1 and makes
HasPendingRequests() false.
Since |callbacks| may have multiple references to a GetClientInfoCallback, this
condition makes sure that we delete callback exactly once.

[nhiroki, 2014/12/08 07:09:33]

Ah sorry, I missed the cancel above. That makes sense.

+      delete callback;
+    iter.Advance();
+  }
+  callbacks->Clear();

[nhiroki, 2014/12/08 05:45:08]

After clearing |callbacks|, GetClientInfo{Success,Error} messages from documents
could reach NOTREACHED at 753 and 775... right?

[Kunihiko Sakamoto, 2014/12/08 06:43:18]

I see. Removed NOTREACHEDs.
I wonder if other callbacks that gets cleared in OnStopped() don't have the same
problem.

[nhiroki, 2014/12/08 07:09:33]

I think other event completion messages (eg. ActivateEventFinished) are sent
from a worker and they shouldn't be sent after the worker stopped.

+}
+
 }  // namespace content