Service Worker: Add a timeout for inflight requests.

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 74 matching lines @@
 template <typename IDMAP, typename... Params>
 void RunIDMapCallbacks(IDMAP* callbacks, const Params&... params) {
   typename IDMAP::iterator iter(callbacks);
   while (!iter.IsAtEnd()) {
     iter.GetCurrentValue()->Run(params...);
     iter.Advance();
   }
   callbacks->Clear();
 }
 
+template <typename CallbackType, typename... Params>
+bool RunIDMapCallback(IDMap<CallbackType, IDMapOwnPointer>* callbacks,
+                      int request_id,
+                      const Params&... params) {
+  CallbackType* callback = callbacks->Lookup(request_id);
+  if (!callback)
+    return false;
+
+  callback->Run(params...);
+  callbacks->Remove(request_id);
+  return true;
+}
+
 void RunStartWorkerCallback(
     const StatusCallback& callback,
     scoped_refptr<ServiceWorkerRegistration> protect,
     ServiceWorkerStatusCode status) {
   callback.Run(status);
 }
 
 // A callback adapter to start a |task| after StartWorker.
 void RunTaskAfterStartWorker(
     base::WeakPtr<ServiceWorkerVersion> version,
@@ skipping 30 matching lines @@
   // Transfering the message ports failed, so destroy the ports.
   for (const TransferredMessagePort& port : sent_message_ports) {
     MessagePortService::GetInstance()->ClosePort(port.id);
   }
   callback.Run(status);
 }
 
 void RunErrorCrossOriginConnectCallback(
     const ServiceWorkerVersion::CrossOriginConnectCallback& callback,
     ServiceWorkerStatusCode status) {
-  callback.Run(status, false);
+  callback.Run(status, false /* accept_connection */);
 }
 
 using WindowOpenedCallback = base::Callback<void(int, int)>;
 
 // The WindowOpenedObserver class is a WebContentsObserver that will wait for a
 // new Window's WebContents to be initialized, run the |callback| passed to its
 // constructor then self destroy.
 // The callback will receive the process and frame ids. If something went wrong
 // those will be (kInvalidUniqueID, MSG_ROUTING_NONE).
 // The callback will be called in the IO thread.
@@ skipping 141 matching lines @@
     clients.push_back(info);
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, clients));
 }
 
 }  // namespace
 
 const int ServiceWorkerVersion::kStartWorkerTimeoutMinutes = 5;
+const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 
 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),
       status_(NEW),
@@ skipping 212 matching lines @@
                            base::Bind(&self::DispatchFetchEvent,
                                       weak_factory_.GetWeakPtr(),
                                       request,
                                       prepare_callback,
                                       fetch_callback)));
     return;
   }
 
   prepare_callback.Run();
 
-  int request_id = fetch_callbacks_.Add(new FetchCallback(fetch_callback));
+  int request_id = AddRequest(fetch_callback, &fetch_callbacks_, REQUEST_FETCH);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_FetchEvent(request_id, request));
   if (status != SERVICE_WORKER_OK) {
     fetch_callbacks_.Remove(request_id);
     RunSoon(base::Bind(&RunErrorFetchCallback,
                        fetch_callback,
                        SERVICE_WORKER_ERROR_FAILED));
   }
 }
 
 void ServiceWorkerVersion::DispatchSyncEvent(const StatusCallback& callback) {
   DCHECK_EQ(ACTIVATED, status()) << status();
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableServiceWorkerSync)) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
                            base::Bind(&self::DispatchSyncEvent,
                                       weak_factory_.GetWeakPtr(),
                                       callback)));
     return;
   }
 
-  int request_id = sync_callbacks_.Add(new StatusCallback(callback));
+  int request_id = AddRequest(callback, &sync_callbacks_, REQUEST_SYNC);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_SyncEvent(request_id));
   if (status != SERVICE_WORKER_OK) {
     sync_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchNotificationClickEvent(
     const StatusCallback& callback,
     const std::string& notification_id,
     const PlatformNotificationData& notification_data) {
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
                            base::Bind(&self::DispatchNotificationClickEvent,
                                       weak_factory_.GetWeakPtr(),
                                       callback, notification_id,
                                       notification_data)));
     return;
   }
 
-  int request_id =
-      notification_click_callbacks_.Add(new StatusCallback(callback));
+  int request_id = AddRequest(callback, &notification_click_callbacks_,
+                              REQUEST_NOTIFICATION_CLICK);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_NotificationClickEvent(request_id,
                                               notification_id,
                                               notification_data));
   if (status != SERVICE_WORKER_OK) {
     notification_click_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchPushEvent(const StatusCallback& callback,
                                              const std::string& data) {
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
                            base::Bind(&self::DispatchPushEvent,
                                       weak_factory_.GetWeakPtr(),
                                       callback, data)));
     return;
   }
 
-  int request_id = push_callbacks_.Add(new StatusCallback(callback));
+  int request_id = AddRequest(callback, &push_callbacks_, REQUEST_PUSH);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_PushEvent(request_id, data));
   if (status != SERVICE_WORKER_OK) {
     push_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchGeofencingEvent(
     const StatusCallback& callback,
@@ skipping 15 matching lines @@
                            callback,
                            base::Bind(&self::DispatchGeofencingEvent,
                                       weak_factory_.GetWeakPtr(),
                                       callback,
                                       event_type,
                                       region_id,
                                       region)));
     return;
   }
 
-  int request_id = geofencing_callbacks_.Add(new StatusCallback(callback));
+  int request_id =
+      AddRequest(callback, &geofencing_callbacks_, REQUEST_GEOFENCING);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_GeofencingEvent(
           request_id, event_type, region_id, region));
   if (status != SERVICE_WORKER_OK) {
     geofencing_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchCrossOriginConnectEvent(
@@ skipping 10 matching lines @@
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(
         base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
                    base::Bind(&RunErrorCrossOriginConnectCallback, callback),
                    base::Bind(&self::DispatchCrossOriginConnectEvent,
                               weak_factory_.GetWeakPtr(), callback, client)));
     return;
   }
 
-  int request_id = cross_origin_connect_callbacks_.Add(
-      new CrossOriginConnectCallback(callback));
+  int request_id = AddRequest(callback, &cross_origin_connect_callbacks_,
+                              REQUEST_CROSS_ORIGIN_CONNECT);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_CrossOriginConnectEvent(request_id, client));
   if (status != SERVICE_WORKER_OK) {
     cross_origin_connect_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status, false));
   }
 }
 
 void ServiceWorkerVersion::DispatchCrossOriginMessageEvent(
     const NavigatorConnectClient& client,
@@ skipping 75 matching lines @@
   if (is_doomed_)
     return;
   is_doomed_ = true;
   if (!HasControllee())
     DoomInternal();
 }
 
 void ServiceWorkerVersion::SetDevToolsAttached(bool attached) {
   embedded_worker()->set_devtools_attached(attached);
   if (attached) {
+    // TODO(falken): Canceling the timeouts when debugging could cause
+    // heisenbugs; we should instead run them as normal show an educational
+    // message in DevTools when they occur. crbug.com/470419
+
     // Don't record the startup time metric once DevTools is attached.
     ClearTick(&start_time_);
     skip_recording_startup_time_ = true;
+
+    // Cancel request timeouts.
+    SetAllRequestTimes(base::TimeTicks());
     return;
   }
   if (!start_callbacks_.empty()) {
     // Reactivate the timer for start timeout.
     DCHECK(timeout_timer_.IsRunning());
     DCHECK(running_status() == STARTING || running_status() == STOPPING)
         << running_status();
     RestartTick(&start_time_);
   }
+
+  // Reactivate request timeouts.
+  SetAllRequestTimes(base::TimeTicks::Now());
 }
 
 void ServiceWorkerVersion::SetMainScriptHttpResponseInfo(
     const net::HttpResponseInfo& http_info) {
   main_script_http_info_.reset(new net::HttpResponseInfo(http_info));
 }
 
 const net::HttpResponseInfo*
 ServiceWorkerVersion::GetMainScriptHttpResponseInfo() {
   return main_script_http_info_.get();
 }
 
+ServiceWorkerVersion::RequestInfo::RequestInfo(int id, RequestType type)
+    : id(id), type(type), time(base::TimeTicks::Now()) {
+}
+
+ServiceWorkerVersion::RequestInfo::~RequestInfo() {
+}
+
 void ServiceWorkerVersion::OnScriptLoaded() {
   DCHECK_EQ(STARTING, running_status());
   // Activate ping/pong now that JavaScript execution will start.
   ping_state_ = PINGING;
 }
 
 void ServiceWorkerVersion::OnStarting() {
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 }
 
@@ skipping 142 matching lines @@
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK)
     RunCallbacks(this, &start_callbacks_, status);
 }
 
 void ServiceWorkerVersion::DispatchInstallEventAfterStartWorker(
     const StatusCallback& callback) {
   DCHECK_EQ(RUNNING, running_status())
       << "Worker stopped too soon after it was started.";
 
-  int request_id = install_callbacks_.Add(new StatusCallback(callback));
+  int request_id = AddRequest(callback, &install_callbacks_, REQUEST_INSTALL);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_InstallEvent(request_id));
   if (status != SERVICE_WORKER_OK) {
     install_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchActivateEventAfterStartWorker(
     const StatusCallback& callback) {
   DCHECK_EQ(RUNNING, running_status())
       << "Worker stopped too soon after it was started.";
 
-  int request_id = activate_callbacks_.Add(new StatusCallback(callback));
+  int request_id = AddRequest(callback, &activate_callbacks_, REQUEST_ACTIVATE);
   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::OnGetClients(
     int request_id,
@@ skipping 540 matching lines @@
       base::TimeDelta::FromMinutes(kStartWorkerTimeoutMinutes)) {
     DCHECK(running_status() == STARTING || running_status() == STOPPING)
         << running_status();
     scoped_refptr<ServiceWorkerVersion> protect(this);
     RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_ERROR_TIMEOUT);
     if (running_status() == STARTING)
       embedded_worker_->Stop();
     return;
   }
 
-  // This check occurs after the start_time_ timeout check, since in that case
-  // the start callbacks should fail with ERROR_TIMEOUT. In the other timeout
-  // checks, there's nothing more to do as the worker is already stopping.
+  // Requests have not finished within a certain period.
+  bool request_timed_out = false;
+  while (!requests_.empty()) {
+    RequestInfo info = requests_.front();
+    if (GetTickDuration(info.time) <
+        base::TimeDelta::FromMinutes(kRequestTimeoutMinutes))
+      break;
+    if (OnRequestTimeout(info))
+      request_timed_out = true;
+    requests_.pop();
+  }
+  if (request_timed_out && running_status() != STOPPING)
+    embedded_worker_->Stop();
+
+  // For the timeouts below, there are no callbacks to timeout so there is
+  // nothing more to do if the worker is already stopping.
   if (running_status() == STOPPING)
     return;
 
   // The worker has been idle for longer than a certain period.
   if (GetTickDuration(idle_time_) >
       base::TimeDelta::FromSeconds(kIdleWorkerTimeoutSeconds)) {
     StopWorkerIfIdle();
     return;
   }
 
@@ skipping 117 matching lines @@
     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();
   }
 }
 
+template <typename CallbackType>
+int ServiceWorkerVersion::AddRequest(
+    const CallbackType& callback,
+    IDMap<CallbackType, IDMapOwnPointer>* callback_map,
+    RequestType request_type) {
+  int request_id = callback_map->Add(new CallbackType(callback));
+  requests_.push(RequestInfo(request_id, request_type));
+  return request_id;
+}
+
+bool ServiceWorkerVersion::OnRequestTimeout(const RequestInfo& info) {
+  switch (info.type) {
+    case REQUEST_ACTIVATE:
+      return RunIDMapCallback(&activate_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_INSTALL:
+      return RunIDMapCallback(&install_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_FETCH:
+      return RunIDMapCallback(
+          &fetch_callbacks_, info.id, SERVICE_WORKER_ERROR_TIMEOUT,
+          /* The other args are ignored for non-OK status. */
+          SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, ServiceWorkerResponse());
+    case REQUEST_SYNC:
+      return RunIDMapCallback(&sync_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_NOTIFICATION_CLICK:
+      return RunIDMapCallback(&notification_click_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_PUSH:
+      return RunIDMapCallback(&push_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_GEOFENCING:
+      return RunIDMapCallback(&geofencing_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_CROSS_ORIGIN_CONNECT:
+      return RunIDMapCallback(&cross_origin_connect_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT,
+                              false /* accept_connection */);
+  }
+  NOTREACHED() << "Got unexpected request type: " << info.type;
+  return false;
+}
+
+void ServiceWorkerVersion::SetAllRequestTimes(const base::TimeTicks& ticks) {
+  std::queue<RequestInfo> new_requests;
+  while (!requests_.empty()) {
+    RequestInfo info = requests_.front();
+    info.time = ticks;
+    new_requests.push(info);
+    requests_.pop();
+  }
+  requests_ = new_requests;
+}
+
 }  // namespace content