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

content/browser/renderer_host/render_process_host_impl.h

 // Copyright (c) 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 155 matching lines @@
   void NotifyTimezoneChange(const std::string& timezone) override;
   shell::InterfaceProvider* GetRemoteInterfaces() override;
   std::unique_ptr<base::SharedPersistentMemoryAllocator> TakeMetricsAllocator()
       override;
   const base::TimeTicks& GetInitTimeForNavigationMetrics() const override;
 #if defined(ENABLE_BROWSER_CDMS)
   scoped_refptr<media::MediaKeys> GetCdm(int render_frame_id,
                                          int cdm_id) const override;
 #endif
   bool IsProcessBackgrounded() const override;
-  void IncrementWorkerRefCount() override;
-  void DecrementWorkerRefCount() override;
+  void IncrementServiceWorkerRefCount() override;
+  void DecrementServiceWorkerRefCount() override;
+  void IncrementSharedWorkerRefCount() override;
+  void DecrementSharedWorkerRefCount() override;
   void PurgeAndSuspend() override;
 
   // IPC::Sender via RenderProcessHost.
   bool Send(IPC::Message* msg) override;
 
   // IPC::Listener via RenderProcessHost.
   bool OnMessageReceived(const IPC::Message& msg) override;
   void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
   void OnBadMessageReceived(const IPC::Message& message) override;
@@ skipping 117 matching lines @@
   // started to swap these in, so the renderer process should not exit if
   // this count is non-zero.
   int32_t pending_views_;
 
  private:
   friend class ChildProcessLauncherBrowserTest_ChildSpawnFail_Test;
   friend class VisitRelayingRenderProcessHost;
   class ConnectionFilterController;
   class ConnectionFilterImpl;
 
+  size_t worker_ref_count() {
+    return service_worker_ref_count_ + shared_worker_ref_count_;
+  }
+
   std::unique_ptr<IPC::ChannelProxy> CreateChannelProxy(
       const std::string& channel_id);
 
   // Creates and adds the IO thread message filters.
   void CreateMessageFilters();
 
   // Registers Mojo interfaces to be exposed to the renderer.
   void RegisterMojoInterfaces();
 
   void CreateStoragePartitionService(
@@ skipping 85 matching lines @@
   std::string child_token_;
 
   std::unique_ptr<MojoChildConnection> mojo_child_connection_;
   int connection_filter_id_ = MojoShellConnection::kInvalidConnectionFilterId;
   scoped_refptr<ConnectionFilterController> connection_filter_controller_;
   shell::mojom::ServicePtr test_service_;
 #if defined(OS_ANDROID)
   std::unique_ptr<InterfaceRegistryAndroid> interface_registry_android_;
 #endif
 
+  size_t service_worker_ref_count_;
+  size_t shared_worker_ref_count_;
+
   // The registered IPC listener objects. When this list is empty, we should
   // delete ourselves.
   IDMap<IPC::Listener> listeners_;
 
   // The count of currently visible widgets.  Since the host can be a container
   // for multiple widgets, it uses this count to determine when it should be
   // backgrounded.
   int32_t visible_widgets_;
 
   // Whether this process currently has backgrounded priority. Tracked so that
@@ skipping 101 matching lines @@
 
   WebRTCEventLogHost webrtc_eventlog_host_;
 #endif
 
   // Forwards messages between WebRTCInternals in the browser process
   // and PeerConnectionTracker in the renderer process.
   // It holds a raw pointer to webrtc_eventlog_host_, and therefore should be
   // defined below it so it is destructed first.
   scoped_refptr<PeerConnectionTrackerHost> peer_connection_tracker_host_;
 
-  int worker_ref_count_;
-
   // Records the time when the process starts surviving for workers for UMA.
   base::TimeTicks survive_for_worker_start_time_;
 
   // Records the maximum # of workers simultaneously hosted in this process
   // for UMA.
-  int max_worker_count_;
+  size_t max_worker_count_;
 
   // Context shared for each mojom::PermissionService instance created for this
   // RPH.
   std::unique_ptr<PermissionServiceContext> permission_service_context_;
 
   // The memory allocator, if any, in which the renderer will write its metrics.
   std::unique_ptr<base::SharedPersistentMemoryAllocator> metrics_allocator_;
 
   bool channel_connected_;
   bool sent_render_process_ready_;
@@ skipping 15 matching lines @@
       instance_weak_factory_;
 
   base::WeakPtrFactory<RenderProcessHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_