Schedule the stop-worker-timer even if the ServiceWorker is controlling pages

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 578 matching lines @@
     cross_origin_connect_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status, false));
   }
 }
 
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   DCHECK(!ContainsKey(controllee_map_, provider_host));
   int controllee_id = controllee_by_id_.Add(provider_host);
   controllee_map_[provider_host] = controllee_id;
-  if (stop_worker_timer_.IsRunning())
-    stop_worker_timer_.Stop();
+  // 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());
   controllee_by_id_.Remove(found->second);
   controllee_map_.erase(found);
   if (HasControllee())
     return;
   FOR_EACH_OBSERVER(Listener, listeners_, OnNoControllees(this));
   if (is_doomed_) {
     DoomInternal();
     return;
   }
-  ScheduleStopWorker();
+  // Schedule the stop-worker-timer if it's not running.
+  if (!stop_worker_timer_.IsRunning())
+    ScheduleStopWorker();
 }
 
 void ServiceWorkerVersion::AddListener(Listener* listener) {
   listeners_.AddObserver(listener);
 }
 
 void ServiceWorkerVersion::RemoveListener(Listener* listener) {
   listeners_.RemoveObserver(listener);
 }
 
@@ skipping 430 matching lines @@
   if (pending_skip_waiting_requests_.size() == 1)
     registration->ActivateWaitingVersionWhenReady();
 }
 
 void ServiceWorkerVersion::DidSkipWaiting(int request_id) {
   if (running_status() == STARTING || running_status() == RUNNING)
     embedded_worker_->SendMessage(ServiceWorkerMsg_DidSkipWaiting(request_id));
 }
 
 void ServiceWorkerVersion::ScheduleStopWorker() {
-  // TODO(kinuko): Currently we don't schedule stop-time-worker when the SW has
-  // controllee, but we should change this default behavior (crbug.com/440259)
-  if (running_status() != RUNNING || HasControllee())
+  if (running_status() != RUNNING)
     return;
   if (stop_worker_timer_.IsRunning()) {
     stop_worker_timer_.Reset();
     return;
   }
   stop_worker_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kStopWorkerDelay),
       base::Bind(&ServiceWorkerVersion::StopWorkerIfIdle,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 27 matching lines @@
   SetStatus(REDUNDANT);
   StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
 }  // namespace content