PlzNavigate: implement process reuse for ServiceWorkers

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 611 matching lines @@
     delete this;
   }
 
   RenderProcessHost* render_process_host_;
   base::OnceClosure task_;
   base::WeakPtrFactory<RenderProcessHostIsReadyObserver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostIsReadyObserver);
 };
 
+// The following object is used to keep track of which sites

[Charlie Reis, 2017/05/23 07:29:13]

nit: s/object/class/
nit: used to track the sites each RenderProcessHost is hosting frames for and
expecting navigations to.

[clamy, 2017/05/23 13:41:15]

Done.

+// RenderProcessHosts are hosting frames and expecting navigations to.
+// There are two of them per BrowserContext, one for frames and one for

[Charlie Reis, 2017/05/23 07:29:13]

nit: Colon rather than comma (to make it seem more like a clarification and less
like a list of 4).

[clamy, 2017/05/23 13:41:15]

Done.

+// navigations.

[Charlie Reis, 2017/05/23 07:29:13]

Can you elaborate a bit further here, explaining how each site is mapped to a
counts_per_process map, and why we chose this direction vs the other one?  I
think it's useful context, to help others decide whether it can be useful in
other ways (e.g., not for security checks asking what's live in a given
process).

[clamy, 2017/05/23 13:41:15]

Done.

+const void* const kCommittedSiteCountPerProcessTrackerKey =
+    "CommittedSiteCountPerProcessTrackerKey";
+const void* const kPendingSiteCountPerProcessTrackerKey =
+    "PendingSiteCountPerProcessTrackerKey";
+class SiteCountPerProcessTracker : public base::SupportsUserData::Data {

[Charlie Reis, 2017/05/23 07:29:13]

nit: Maybe SiteProcessCountTracker (now that we've changed the struct)?

Same in the key names above.

[clamy, 2017/05/23 13:41:15]

Done.

+ public:
+  SiteCountPerProcessTracker() {}
+  ~SiteCountPerProcessTracker() override {}
+
+  void AddCountForSiteForProcess(int render_process_host_id,

[Charlie Reis, 2017/05/23 07:29:13]

nit: IncrementSiteProcessCount
nit: Swap parameter order, since the map goes from site to (process -> count).

[clamy, 2017/05/23 13:41:15]

Done.

+                                 const GURL& site_url) {
+    std::map<ProcessID, Count>& counts_per_process = map_[site_url];
+    ++counts_per_process[render_process_host_id];
+  }
+
+  void RemoveCountForSiteForProcess(int render_process_host_id,

[Charlie Reis, 2017/05/23 07:29:13]

nit: DecrementSiteProcessCount and swap parameter order

[clamy, 2017/05/23 13:41:15]

Done.

+                                    const GURL& site_url) {
+    auto result = map_.find(site_url);
+    DCHECK(result != map_.end());
+    std::map<ProcessID, Count>& counts_per_process = result->second;
+
+    --counts_per_process[render_process_host_id];
+    DCHECK(counts_per_process[render_process_host_id] >= 0);
+
+    if (counts_per_process[render_process_host_id] == 0)
+      counts_per_process.erase(render_process_host_id);
+
+    if (counts_per_process.empty())
+      map_.erase(site_url);
+  }
+
+  void FindRenderProcessesForSite(
+      const GURL& site_url,
+      std::set<RenderProcessHost*>* foreground_processes,
+      std::set<RenderProcessHost*>* background_processes) {
+    auto result = map_.find(site_url);
+    if (result == map_.end())
+      return;
+
+    std::map<ProcessID, Count>& counts_per_process = result->second;
+    for (auto iter : counts_per_process) {
+      RenderProcessHost* host = RenderProcessHost::FromID(iter.first);
+      DCHECK(host);
+      if (host->VisibleWidgetCount())
+        foreground_processes->insert(host);
+      else
+        background_processes->insert(host);
+    }
+  }
+
+ private:
+  using ProcessID = int;
+  using Count = int;
+  using CountPerProcessPerSiteMap = std::map<GURL, std::map<ProcessID, Count>>;
+  CountPerProcessPerSiteMap map_;
+};
+
 }  // namespace
 
 RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;
 
 base::MessageLoop* g_in_process_thread;
 
 // Stores the maximum number of renderer processes the content module can
 // create.
 static size_t g_max_renderer_count_override = 0;
 
@@ skipping 1099 matching lines @@
   DCHECK_GT(audio_stream_count_, 0);
   --audio_stream_count_;
   UpdateProcessPriority();
 }
 
 void RenderProcessHostImpl::set_render_process_host_factory(
     const RenderProcessHostFactory* rph_factory) {
   g_render_process_host_factory_ = rph_factory;
 }
 
+// static
+void RenderProcessHostImpl::AddFrameWithSite(
+    BrowserContext* browser_context,
+    RenderProcessHost* render_process_host,
+    const GURL& site_url) {
+  if (site_url.is_empty())
+    return;
+
+  SiteCountPerProcessTracker* tracker =
+      static_cast<SiteCountPerProcessTracker*>(browser_context->GetUserData(
+          kCommittedSiteCountPerProcessTrackerKey));
+  if (!tracker) {
+    tracker = new SiteCountPerProcessTracker();
+    browser_context->SetUserData(kCommittedSiteCountPerProcessTrackerKey,
+                                 base::WrapUnique(tracker));
+  }
+  tracker->AddCountForSiteForProcess(render_process_host->GetID(), site_url);
+}
+
+// static
+void RenderProcessHostImpl::RemoveFrameWithSite(
+    BrowserContext* browser_context,
+    RenderProcessHost* render_process_host,
+    const GURL& site_url) {
+  if (site_url.is_empty())
+    return;
+
+  SiteCountPerProcessTracker* tracker =
+      static_cast<SiteCountPerProcessTracker*>(browser_context->GetUserData(
+          kCommittedSiteCountPerProcessTrackerKey));
+  if (!tracker) {
+    tracker = new SiteCountPerProcessTracker();
+    browser_context->SetUserData(kCommittedSiteCountPerProcessTrackerKey,
+                                 base::WrapUnique(tracker));
+  }
+  tracker->RemoveCountForSiteForProcess(render_process_host->GetID(), site_url);
+}
+
+// static
+void RenderProcessHostImpl::AddExpectedNavigationToSite(
+    BrowserContext* browser_context,
+    RenderProcessHost* render_process_host,
+    const GURL& site_url) {
+  if (site_url.is_empty())
+    return;
+
+  SiteCountPerProcessTracker* tracker =
+      static_cast<SiteCountPerProcessTracker*>(
+          browser_context->GetUserData(kPendingSiteCountPerProcessTrackerKey));
+  if (!tracker) {
+    tracker = new SiteCountPerProcessTracker();
+    browser_context->SetUserData(kPendingSiteCountPerProcessTrackerKey,
+                                 base::WrapUnique(tracker));
+  }
+  tracker->AddCountForSiteForProcess(render_process_host->GetID(), site_url);
+}
+
+// static
+void RenderProcessHostImpl::RemoveExpectedNavigationToSite(
+    BrowserContext* browser_context,
+    RenderProcessHost* render_process_host,
+    const GURL& site_url) {
+  if (site_url.is_empty())
+    return;
+
+  SiteCountPerProcessTracker* tracker =
+      static_cast<SiteCountPerProcessTracker*>(
+          browser_context->GetUserData(kPendingSiteCountPerProcessTrackerKey));
+  if (!tracker) {
+    tracker = new SiteCountPerProcessTracker();
+    browser_context->SetUserData(kPendingSiteCountPerProcessTrackerKey,
+                                 base::WrapUnique(tracker));
+  }
+  tracker->RemoveCountForSiteForProcess(render_process_host->GetID(), site_url);
+}
+
 bool RenderProcessHostImpl::IsForGuestsOnly() const {
   return is_for_guests_only_;
 }
 
 StoragePartition* RenderProcessHostImpl::GetStoragePartition() const {
   return storage_partition_impl_;
 }
 
 static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
   command_line->AppendSwitchASCII(
@@ skipping 1105 matching lines @@
   // First, attempt to reuse an existing RenderProcessHost if necessary.
   switch (process_reuse_policy) {
     case SiteInstanceImpl::ProcessReusePolicy::PROCESS_PER_SITE:
       render_process_host = GetProcessHostForSite(browser_context, site_url);
       break;
     case SiteInstanceImpl::ProcessReusePolicy::USE_DEFAULT_SUBFRAME_PROCESS:
       DCHECK(SiteIsolationPolicy::IsTopDocumentIsolationEnabled());
       render_process_host = GetDefaultSubframeProcessHost(
           browser_context, site_instance, is_for_guests_only);
       break;
+    case SiteInstanceImpl::ProcessReusePolicy::REUSE_PENDING_OR_COMMITTED_SITE:
+      render_process_host =
+          FindReusableProcessHostForSite(browser_context, site_url);
+      break;
     default:
       break;
   }
 
   // If not (or if none found), see if we should reuse an existing process.
   if (!render_process_host &&
       ShouldTryToUseExistingProcessHost(browser_context, site_url)) {
     render_process_host = GetExistingProcessHost(browser_context, site_url);
   }
 
@@ skipping 372 matching lines @@
           browser_context->GetUserData(&kDefaultSubframeProcessHostHolderKey));
   if (!holder) {
     holder = new DefaultSubframeProcessHostHolder(browser_context);
     browser_context->SetUserData(kDefaultSubframeProcessHostHolderKey,
                                  base::WrapUnique(holder));
   }
 
   return holder->GetProcessHost(site_instance, is_for_guests_only);
 }
 
+// static
+RenderProcessHost* RenderProcessHostImpl::FindReusableProcessHostForSite(
+    BrowserContext* browser_context,
+    const GURL& site_url) {
+  if (site_url.is_empty())
+    return nullptr;
+
+  std::set<RenderProcessHost*> eligible_foreground_hosts;
+  std::set<RenderProcessHost*> eligible_background_hosts;
+
+  // Add the RenderProcessHosts hosting a frame for |site_url| to the list of
+  // eligible RenderProcessHosts.
+  SiteCountPerProcessTracker* committed_tracker =
+      static_cast<SiteCountPerProcessTracker*>(browser_context->GetUserData(
+          kCommittedSiteCountPerProcessTrackerKey));
+  if (committed_tracker) {
+    committed_tracker->FindRenderProcessesForSite(
+        site_url, &eligible_foreground_hosts, &eligible_background_hosts);
+  }
+
+  // Add the RenderProcessHosts expecting a navigation to |site_url| to the list
+  // of eligible RenderProcessHosts.
+  SiteCountPerProcessTracker* pending_tracker =
+      static_cast<SiteCountPerProcessTracker*>(
+          browser_context->GetUserData(kPendingSiteCountPerProcessTrackerKey));
+  if (pending_tracker) {
+    pending_tracker->FindRenderProcessesForSite(
+        site_url, &eligible_foreground_hosts, &eligible_background_hosts);

[Charlie Reis, 2017/05/23 07:29:14]

Should there be any preference between processes that have a committed site URL
and those that are only expecting a site URL?  Seems like they'll go into the
same set and be picked randomly.  Maybe that's what ServiceWorker does today?

[clamy, 2017/05/23 13:41:15]

I think it would prioritize the navigating ones today (they try to put it in the
process that is navigating). I have updated the code so that it does, as long as
it finds a foreground one.

+  }
+
+  if (!eligible_foreground_hosts.empty()) {
+    int index = base::RandInt(0, eligible_foreground_hosts.size() - 1);
+    auto iterator = eligible_foreground_hosts.begin();
+    for (int i = 0; i < index; ++i)
+      ++iterator;
+    return (*iterator);
+  }
+
+  if (!eligible_background_hosts.empty()) {
+    int index = base::RandInt(0, eligible_background_hosts.size() - 1);
+    auto iterator = eligible_background_hosts.begin();
+    for (int i = 0; i < index; ++i)
+      ++iterator;
+    return (*iterator);
+  }
+
+  return nullptr;
+}
+
 #if BUILDFLAG(ENABLE_WEBRTC)
 void RenderProcessHostImpl::OnRegisterAecDumpConsumer(int id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&RenderProcessHostImpl::RegisterAecDumpConsumerOnUIThread,
                  weak_factory_.GetWeakPtr(), id));
 }
 
 void RenderProcessHostImpl::OnUnregisterAecDumpConsumer(int id) {
   BrowserThread::PostTask(
@@ skipping 70 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