Relax timeout for starting a service worker from 10 sec to 1 minute.

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 <stddef.h>
 
 #include <map>
 #include <string>
@@ skipping 187 matching lines @@
     case ServiceWorkerVersion::ACTIVATED:
       return true;
   }
   NOTREACHED() << "Unexpected status: " << status;
   return false;
 }
 
 }  // namespace
 
 const int ServiceWorkerVersion::kTimeoutTimerDelaySeconds = 30;
-const int ServiceWorkerVersion::kStartInstalledWorkerTimeoutSeconds = 10;
+const int ServiceWorkerVersion::kStartInstalledWorkerTimeoutSeconds = 60;
 const int ServiceWorkerVersion::kStartNewWorkerTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kStopWorkerTimeoutSeconds = 5;
 
 class ServiceWorkerVersion::Metrics {
  public:
   using EventType = ServiceWorkerMetrics::EventType;
   explicit Metrics(ServiceWorkerVersion* owner) : owner_(owner) {}
   ~Metrics() {
     if (owner_->should_exclude_from_uma_)
@@ skipping 582 matching lines @@
 }
 
 void ServiceWorkerVersion::OnStarting() {
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 }
 
 void ServiceWorkerVersion::OnStarted() {
   DCHECK_EQ(RUNNING, running_status());
   RestartTick(&idle_time_);
 
-  // Reset the interval to normal. If may have been shortened so starting an
-  // existing worker can timeout quickly.
-  SetTimeoutTimerInterval(
-      base::TimeDelta::FromSeconds(kTimeoutTimerDelaySeconds));
-
   // Fire all start callbacks.
   scoped_refptr<ServiceWorkerVersion> protect(this);
   RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK);
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 }
 
 void ServiceWorkerVersion::OnStopping() {
   DCHECK(stop_time_.is_null());
   RestartTick(&stop_time_);
 
@@ skipping 559 matching lines @@
     RestartTick(&start_time_);
     skip_recording_startup_time_ = false;
   }
 
   // The worker is starting up and not yet idle.
   ClearTick(&idle_time_);
 
   // Ping will be activated in OnScriptLoaded.
   ping_controller_->Deactivate();
 
-  // Make the timer delay shorter for starting an existing
-  // worker so stalled in starting workers can be timed out quickly.
-  // The timer will be reset to normal in OnStarted or the next start
-  // attempt.
-  const int delay_in_seconds = IsInstalled(status_)
-                                   ? kStartInstalledWorkerTimeoutSeconds
-                                   : kTimeoutTimerDelaySeconds;
   timeout_timer_.Start(FROM_HERE,
-                       base::TimeDelta::FromSeconds(delay_in_seconds), this,
-                       &ServiceWorkerVersion::OnTimeoutTimer);
+                       base::TimeDelta::FromSeconds(kTimeoutTimerDelaySeconds),
+                       this, &ServiceWorkerVersion::OnTimeoutTimer);
 }
 
 void ServiceWorkerVersion::StopTimeoutTimer() {
   timeout_timer_.Stop();
   ClearTick(&idle_time_);
 
   // Trigger update if worker is stale.
   if (!in_dtor_ && !stale_time_.is_null()) {
     ClearTick(&stale_time_);
     if (!update_timer_.IsRunning())
@@ skipping 354 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content