Forcibly clear worker ref counts on shutdown.

content/browser/shared_worker/shared_worker_service_impl.cc

 // Copyright 2014 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/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 13 matching lines @@
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/worker_service_observer.h"
 
 namespace content {
 
 WorkerService* WorkerService::GetInstance() {
   return SharedWorkerServiceImpl::GetInstance();
 }
 
+bool IsHostAlive(RenderProcessHost* host) {
+  return host && !host->FastShutdownStarted() &&
+         !host->IsWorkerRefCountDisabled();
+}
+
 namespace {
 
 class ScopedWorkerDependencyChecker {
  public:
   explicit ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service)
       : service_(service) {}
   ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service,
                                 base::Closure done_closure)
       : service_(service), done_closure_(done_closure) {}
   ~ScopedWorkerDependencyChecker() {
     service_->CheckWorkerDependency();
     if (!done_closure_.is_null())
       done_closure_.Run();
   }
 
  private:
   SharedWorkerServiceImpl* service_;
   base::Closure done_closure_;
   DISALLOW_COPY_AND_ASSIGN(ScopedWorkerDependencyChecker);
 };
 
 void UpdateWorkerDependencyOnUI(const std::vector<int>& added_ids,
                                 const std::vector<int>& removed_ids) {
   for (int id : added_ids) {
     RenderProcessHostImpl* render_process_host_impl =
         static_cast<RenderProcessHostImpl*>(RenderProcessHost::FromID(id));
-    if (!render_process_host_impl)
+    if (!IsHostAlive(render_process_host_impl))
       continue;
     render_process_host_impl->IncrementSharedWorkerRefCount();
   }
   for (int id : removed_ids) {
     RenderProcessHostImpl* render_process_host_impl =
         static_cast<RenderProcessHostImpl*>(RenderProcessHost::FromID(id));
-    if (!render_process_host_impl)
+    if (!IsHostAlive(render_process_host_impl))
       continue;
     render_process_host_impl->DecrementSharedWorkerRefCount();
   }
 }
 
 void UpdateWorkerDependency(const std::vector<int>& added_ids,
                             const std::vector<int>& removed_ids) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&UpdateWorkerDependencyOnUI, added_ids, removed_ids));
 }
 
 void DecrementWorkerRefCount(int process_id) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&DecrementWorkerRefCount, process_id));
     return;
   }
   RenderProcessHostImpl* render_process_host_impl =
       static_cast<RenderProcessHostImpl*>(
           RenderProcessHost::FromID(process_id));
-  if (render_process_host_impl)
+  if (IsHostAlive(render_process_host_impl))
     render_process_host_impl->DecrementSharedWorkerRefCount();
 }
 
 bool TryIncrementWorkerRefCount(int worker_process_id) {
   RenderProcessHostImpl* render_process = static_cast<RenderProcessHostImpl*>(
       RenderProcessHost::FromID(worker_process_id));
-  if (!render_process || render_process->FastShutdownStarted())
+  if (!IsHostAlive(render_process))
     return false;
   render_process->IncrementSharedWorkerRefCount();
   return true;
 }
 
 }  // namespace
 
 class SharedWorkerServiceImpl::SharedWorkerPendingInstance {
  public:
   struct SharedWorkerPendingRequest {
@@ skipping 574 matching lines @@
     UpdateWorkerDependencyFunc new_func) {
   update_worker_dependency_ = new_func;
 }
 
 void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting(
     bool (*new_func)(int)) {
   s_try_increment_worker_ref_count_ = new_func;
 }
 
 }  // namespace content