MemoryCoordinator checks if ServiceWorker exists on the suspending process

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 2012 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 1352 matching lines @@
 
 const base::TimeTicks& RenderProcessHostImpl::GetInitTimeForNavigationMetrics()
     const {
   return init_time_;
 }
 
 bool RenderProcessHostImpl::IsProcessBackgrounded() const {
   return is_process_backgrounded_;
 }
 
+size_t RenderProcessHostImpl::GetWorkerRefCount() const {
+  return service_worker_ref_count_ + shared_worker_ref_count_;

[horo, 2016/12/13 06:29:33]

DCHECK_CURRENTLY_ON(BrowserThread::UI);

[shimazu, 2016/12/13 07:24:50]

Done.

+}
+
 void RenderProcessHostImpl::IncrementServiceWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_worker_ref_count_disabled_);
   ++service_worker_ref_count_;
-  if (worker_ref_count() > max_worker_count_)
-    max_worker_count_ = worker_ref_count();
+  if (GetWorkerRefCount() > max_worker_count_)
+    max_worker_count_ = GetWorkerRefCount();
 }
 
 void RenderProcessHostImpl::DecrementServiceWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_worker_ref_count_disabled_);
-  DCHECK_GT(worker_ref_count(), 0U);
+  DCHECK_GT(GetWorkerRefCount(), 0U);
   --service_worker_ref_count_;
-  if (worker_ref_count() == 0)
+  if (GetWorkerRefCount() == 0)
     Cleanup();
 }
 
 void RenderProcessHostImpl::IncrementSharedWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_worker_ref_count_disabled_);
   ++shared_worker_ref_count_;
-  if (worker_ref_count() > max_worker_count_)
-    max_worker_count_ = worker_ref_count();
+  if (GetWorkerRefCount() > max_worker_count_)
+    max_worker_count_ = GetWorkerRefCount();
 }
 
 void RenderProcessHostImpl::DecrementSharedWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_worker_ref_count_disabled_);
-  DCHECK_GT(worker_ref_count(), 0U);
+  DCHECK_GT(GetWorkerRefCount(), 0U);
   --shared_worker_ref_count_;
-  if (worker_ref_count() == 0)
+  if (GetWorkerRefCount() == 0)
     Cleanup();
 }
 
 void RenderProcessHostImpl::ForceReleaseWorkerRefCounts() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_worker_ref_count_disabled_);
   is_worker_ref_count_disabled_ = true;
-  if (!worker_ref_count())
+  if (!GetWorkerRefCount())
     return;
   service_worker_ref_count_ = 0;
   shared_worker_ref_count_ = 0;
   Cleanup();
 }
 
 bool RenderProcessHostImpl::IsWorkerRefCountDisabled() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return is_worker_ref_count_disabled_;
 }
@@ skipping 505 matching lines @@
     return false;  // Render process hasn't started or is probably crashed.
 
   // Test if there's an unload listener.
   // NOTE: It's possible that an onunload listener may be installed
   // while we're shutting down, so there's a small race here.  Given that
   // the window is small, it's unlikely that the web page has much
   // state that will be lost by not calling its unload handlers properly.
   if (!SuddenTerminationAllowed())
     return false;
 
-  if (worker_ref_count() != 0) {
+  if (GetWorkerRefCount() != 0) {
     if (survive_for_worker_start_time_.is_null())
       survive_for_worker_start_time_ = base::TimeTicks::Now();
     return false;
   }
 
   // Set this before ProcessDied() so observers can tell if the render process
   // died due to fast shutdown versus another cause.
   fast_shutdown_started_ = true;
 
   ProcessDied(false /* already_dead */, nullptr);
@@ skipping 157 matching lines @@
   // delay the destruction until all of the observer callbacks have been made,
   // and guarantee that the RenderProcessHostDestroyed observer callback is
   // always the last callback fired.
   if (within_process_died_observer_) {
     delayed_cleanup_needed_ = true;
     return;
   }
   delayed_cleanup_needed_ = false;
 
   // Records the time when the process starts surviving for workers for UMA.
-  if (listeners_.IsEmpty() && worker_ref_count() > 0 &&
+  if (listeners_.IsEmpty() && GetWorkerRefCount() > 0 &&
       survive_for_worker_start_time_.is_null()) {
     survive_for_worker_start_time_ = base::TimeTicks::Now();
   }
 
   // Until there are no other owners of this object, we can't delete ourselves.
-  if (!listeners_.IsEmpty() || worker_ref_count() != 0)
+  if (!listeners_.IsEmpty() || GetWorkerRefCount() != 0)
     return;
 
 #if BUILDFLAG(ENABLE_WEBRTC)
   if (is_initialized_)
     ClearWebRtcLogMessageCallback();
 #endif
 
   if (!survive_for_worker_start_time_.is_null()) {
     UMA_HISTOGRAM_LONG_TIMES(
         "SharedWorker.RendererSurviveForWorkerTime",
@@ skipping 870 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing.
   // Capture the error message in a crash key value.
   base::debug::ScopedCrashKey error_key_value("mojo-message-error", error);
   bad_message::ReceivedBadMessage(render_process_id,
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content