Add ref count to service workers for extension API.

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 <limits>
 #include <map>
@@ skipping 37 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 
 namespace content {
 
 using StatusCallback = ServiceWorkerVersion::StatusCallback;
 
 namespace {
 
 // Time to wait until stopping an idle worker.
-const int kIdleWorkerTimeoutSeconds = 30;
+const int kIdleWorkerTimeoutSeconds = 3;
 
 // Default delay for scheduled update.
 const int kUpdateDelaySeconds = 1;
 
 // Timeout for waiting for a response to a ping.
 const int kPingTimeoutSeconds = 30;
 
 const char kClaimClientsStateErrorMesage[] =
     "Only the active worker can claim clients.";
 
@@ skipping 116 matching lines @@
   if (trace_id == std::numeric_limits<int>::max())
     trace_id = 0;
   else
     ++trace_id;
   DCHECK_NE(kInvalidTraceId, trace_id);
   return trace_id;
 }
 
 }  // namespace
 
-const int ServiceWorkerVersion::kTimeoutTimerDelaySeconds = 30;
+const int ServiceWorkerVersion::kTimeoutTimerDelaySeconds = 3;

[falken, 2016/07/22 05:06:02]

Are these timer changes just for proof of concept?

I'm not sure we want to do this in production. The timers are intentionally slow
so SW doesn't cause too much work in the browser process and we also keep SW
alive for a while in case it'll need to be used again (for example, initial page
load, user looks at page for a while, then clicks a link).

[lazyboy, 2016/07/26 17:45:48]

Yes, these are entirely for proof of concept, especially for running the test
locally for now.

I need to find a better way to test the timeout behavior in tests. Once the CL
progresses, I'll do so.

 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() {
@@ skipping 1199 matching lines @@
 void ServiceWorkerVersion::SetTimeoutTimerInterval(base::TimeDelta interval) {
   DCHECK(timeout_timer_.IsRunning());
   if (timeout_timer_.GetCurrentDelay() != interval) {
     timeout_timer_.Stop();
     timeout_timer_.Start(FROM_HERE, interval, this,
                          &ServiceWorkerVersion::OnTimeoutTimer);
   }
 }
 
 void ServiceWorkerVersion::OnTimeoutTimer() {
+  LOG(ERROR) << "ServiceWorkerVersion::OnTimeoutTimer";
   DCHECK(running_status() == EmbeddedWorkerStatus::STARTING ||
          running_status() == EmbeddedWorkerStatus::RUNNING ||
          running_status() == EmbeddedWorkerStatus::STOPPING)
       << static_cast<int>(running_status());
 
   if (!context_)
     return;
 
   MarkIfStale();
 
@@ skipping 86 matching lines @@
 void ServiceWorkerVersion::OnPingTimeout() {
   DCHECK(running_status() == EmbeddedWorkerStatus::STARTING ||
          running_status() == EmbeddedWorkerStatus::RUNNING);
   // TODO(falken): Show a message to the developer that the SW was stopped due
   // to timeout (crbug.com/457968). Also, change the error code to
   // SERVICE_WORKER_ERROR_TIMEOUT.
   StopWorkerIfIdle();
 }
 
 void ServiceWorkerVersion::StopWorkerIfIdle() {
+  LOG(ERROR) << "ServiceWorkerVersion::StopWorkerIfIdle";
   if (HasWork() && !ping_controller_->IsTimedOut())
     return;
   if (running_status() == EmbeddedWorkerStatus::STOPPED ||
       running_status() == EmbeddedWorkerStatus::STOPPING ||
       !stop_callbacks_.empty()) {
     return;
   }
 
   embedded_worker_->StopIfIdle();
 }
@@ skipping 206 matching lines @@
   if (should_exclude_from_uma_ ||
       running_status() != EmbeddedWorkerStatus::RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content