For debugging, split worker ref count into service worker and shared worker counts

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 654 matching lines @@
     BrowserContext* browser_context,
     StoragePartitionImpl* storage_partition_impl,
     bool is_for_guests_only)
     : fast_shutdown_started_(false),
       deleting_soon_(false),
 #ifndef NDEBUG
       is_self_deleted_(false),
 #endif
       pending_views_(0),
       child_token_(mojo::edk::GenerateRandomToken()),
+      service_worker_ref_count_(0),
+      shared_worker_ref_count_(0),
       visible_widgets_(0),
       is_process_backgrounded_(false),
       is_initialized_(false),
       id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
       browser_context_(browser_context),
       storage_partition_impl_(storage_partition_impl),
       sudden_termination_allowed_(true),
       ignore_input_events_(false),
       is_for_guests_only_(is_for_guests_only),
       gpu_observer_registered_(false),
       delayed_cleanup_needed_(false),
       within_process_died_observer_(false),
       power_monitor_broadcaster_(this),
 #if defined(ENABLE_WEBRTC)
       webrtc_eventlog_host_(id_),
 #endif
-      worker_ref_count_(0),
       max_worker_count_(0),
       permission_service_context_(new PermissionServiceContext(this)),
       channel_connected_(false),
       sent_render_process_ready_(false),
 #if defined(OS_ANDROID)
       never_signaled_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED),
 #endif
       instance_weak_factory_(
           new base::WeakPtrFactory<RenderProcessHostImpl>(this)),
@@ skipping 90 matching lines @@
 // static
 // TODO(alokp): Remove after collecting crash data.
 // Temporary checks to verify that all shared workers are terminated.
 // It is suspected that shared workers prevent render process hosts
 // from shutting down: crbug.com/608049
 void RenderProcessHostImpl::CheckAllWorkersTerminated() {
   iterator iter(AllHostsIterator());
   while (!iter.IsAtEnd()) {
     RenderProcessHostImpl* host =
         static_cast<RenderProcessHostImpl*>(iter.GetCurrentValue());
-    CHECK_EQ(0, host->worker_ref_count_);
+    if (host->worker_ref_count() != 0) {
+      std::string message = base::StringPrintf(
+          "%zu service workers, %zu shared workers",
+          host->service_worker_ref_count_, host->shared_worker_ref_count_);
+      // Use separate CHECKs for better crash report readability.
+      CHECK(host->service_worker_ref_count_ == 0 ||
+            host->shared_worker_ref_count_ == 0)
+          << message;
+      CHECK_EQ(0UL, host->service_worker_ref_count_) << message;
+      CHECK_EQ(0UL, host->shared_worker_ref_count_) << message;
+    }
+
+    iter.Advance();
   }
 }
 
 RenderProcessHostImpl::~RenderProcessHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #ifndef NDEBUG
   DCHECK(is_self_deleted_)
       << "RenderProcessHostImpl is destroyed by something other than itself";
 #endif
 
@@ skipping 503 matching lines @@
   if (!manager)
     return nullptr;
   return manager->GetCdm(render_frame_id, cdm_id);
 }
 #endif
 
 bool RenderProcessHostImpl::IsProcessBackgrounded() const {
   return is_process_backgrounded_;
 }
 
-void RenderProcessHostImpl::IncrementWorkerRefCount() {
+void RenderProcessHostImpl::IncrementServiceWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ++worker_ref_count_;
-  if (worker_ref_count_ > max_worker_count_)
-    max_worker_count_ = worker_ref_count_;
+  ++service_worker_ref_count_;
+  if (worker_ref_count() > max_worker_count_)
+    max_worker_count_ = worker_ref_count();
 }
 
-void RenderProcessHostImpl::DecrementWorkerRefCount() {
+void RenderProcessHostImpl::DecrementServiceWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_GT(worker_ref_count_, 0);
-  --worker_ref_count_;
-  if (worker_ref_count_ == 0)
+  DCHECK_GT(worker_ref_count(), 0UL);
+  --service_worker_ref_count_;
+  if (worker_ref_count() == 0)
     Cleanup();
 }
 
+void RenderProcessHostImpl::IncrementSharedWorkerRefCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  ++shared_worker_ref_count_;
+  if (worker_ref_count() > max_worker_count_)
+    max_worker_count_ = worker_ref_count();
+}
+
+void RenderProcessHostImpl::DecrementSharedWorkerRefCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_GT(worker_ref_count(), 0UL);
+  --shared_worker_ref_count_;
+  if (worker_ref_count() == 0)
+    Cleanup();
+}
+
 void RenderProcessHostImpl::PurgeAndSuspend() {
   Send(new ChildProcessMsg_PurgeAndSuspend());
 }
 
 void RenderProcessHostImpl::AddRoute(int32_t routing_id,
                                      IPC::Listener* listener) {
   CHECK(!listeners_.Lookup(routing_id)) << "Found Routing ID Conflict: "
                                         << routing_id;
   listeners_.AddWithID(listener, routing_id);
 }
@@ skipping 481 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 (worker_ref_count() != 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 165 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() && worker_ref_count() > 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() || worker_ref_count() != 0)
     return;
 
 #if defined(ENABLE_WEBRTC)
   if (is_initialized_)
     ClearWebRtcLogMessageCallback();
 #endif
 
   if (!survive_for_worker_start_time_.is_null()) {
     UMA_HISTOGRAM_LONG_TIMES(
         "SharedWorker.RendererSurviveForWorkerTime",
@@ skipping 889 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing. Alias
   // enough information here so that we can determine what the bad message was.
   base::debug::Alias(&error);
   bad_message::ReceivedBadMessage(process.get(),
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content