[TabManager] Disable memory pressure notifications to foreground renderers.

chrome/browser/memory/tab_manager.cc

 // 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.
 
 #include "chrome/browser/memory/tab_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 239 matching lines @@
   std::sort(stats_list.begin(), stats_list.end(), CompareTabStats);
   return stats_list;
 }
 
 std::vector<content::RenderProcessHost*> TabManager::GetOrderedRenderers() {
   // Get the tab stats.
   auto tab_stats = GetTabStats();
 
   std::vector<content::RenderProcessHost*> sorted_renderers;
   std::set<content::RenderProcessHost*> seen_renderers;
+  std::set<content::RenderProcessHost*> visible_renderers;
   sorted_renderers.reserve(tab_stats.size());
 
   // Convert the tab sort order to a process sort order. The process inherits
   // the priority of its highest priority tab.
   for (auto& tab : tab_stats) {
+    auto renderer = tab.render_process_host;
+
+    // Skip renderers associated with visible tabs as handling memory pressure
+    // notifications in these processes can cause jank. This code works because
+    // visible tabs always come first in |tab_stats|.
+    if (tab.is_selected) {
+      visible_renderers.insert(renderer);
+      continue;
+    }
+    if (visible_renderers.count(renderer) > 0)
+      continue;
+
     // Skip renderers that have already been encountered. This can occur when
     // multiple tabs are folded into a single renderer process. In this case the
     // process takes the priority of its highest priority contained tab.
-    auto renderer = tab.render_process_host;
     if (!seen_renderers.insert(renderer).second)
       continue;
 
     sorted_renderers.push_back(renderer);
   }
 
   return sorted_renderers;
 }
 
 bool TabManager::IsTabDiscarded(content::WebContents* contents) const {
@@ skipping 469 matching lines @@
   if (level == base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
     under_memory_pressure_ = false;
     notified_renderers_.clear();
     return;
   }
 
   // Get a vector of active renderers, from highest to lowest priority.
   auto renderers = GetOrderedRenderers();
 
   // The following code requires at least one renderer to be present or it will
-  // busyloop. It's possible (however unlikely) for no renderers to exist, so
-  // bail early if that's the case.
+  // busyloop. It's possible for no renderers to exist (we eliminate visible
+  // renderers to avoid janking them), so bail early if that's the case.
   if (renderers.empty())
     return;
 
   // Notify a single renderer of memory pressure.
   bool notified = false;
   while (!notified) {
     // Notify the lowest priority renderer that hasn't been notified yet.
     for (auto rit = renderers.rbegin(); rit != renderers.rend(); ++rit) {
       // If this renderer has already been notified then look at the next one.
       if (!notified_renderers_.insert(*rit).second)
@@ skipping 19 matching lines @@
   // Schedule another notification. Use a weak pointer so this doesn't explode
   // during tear down.
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TabManager::DoChildProcessDispatch,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kRendererNotificationDelayInSeconds));
 }
 
 }  // namespace memory