Remove renderer notifications of memory pressure.

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_monitor.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/observer_list.h"
 #include "base/process/process.h"
 #include "base/rand_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/tick_clock.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h"
 #include "chrome/browser/memory/oom_memory_details.h"
 #include "chrome/browser/memory/tab_manager_observer.h"
 #include "chrome/browser/memory/tab_manager_web_contents_data.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "components/metrics/system_memory_stats_recorder.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/memory_pressure_controller.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_importance_signals.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/multi_profile_uma.h"
 #include "ash/shell_port.h"
 #include "chrome/browser/memory/tab_manager_delegate_chromeos.h"
 #include "components/user_manager/user_manager.h"
@@ skipping 27 matching lines @@
   for (int idx = 0; idx < model->count(); idx++) {
     WebContents* web_contents = model->GetWebContentsAt(idx);
     int64_t web_contents_id = TabManager::IdFromWebContents(web_contents);
     if (web_contents_id == target_web_contents_id)
       return idx;
   }
 
   return -1;
 }
 
-// A wrapper around base::MemoryPressureMonitor::GetCurrentPressureLevel.
-// TODO(chrisha): Move this do the default implementation of a delegate.
-base::MemoryPressureListener::MemoryPressureLevel
-GetCurrentPressureLevel() {
-  auto* monitor = base::MemoryPressureMonitor::Get();
-  if (monitor)
-    return monitor->GetCurrentPressureLevel();
-  return base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-}
-
-// A wrapper to content::SendPressureNotification that doesn't have overloaded
-// type ambiguity. Makes use of Bind easier.
-// TODO(chrisha): Move this do the default implementation of a delegate.
-void NotifyRendererProcess(
-    const content::RenderProcessHost* render_process_host,
-    base::MemoryPressureListener::MemoryPressureLevel level) {
-  content::MemoryPressureController::SendPressureNotification(
-      render_process_host, level);
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabManager
 
 constexpr base::TimeDelta TabManager::kDefaultMinTimeToPurge;
 
 TabManager::TabManager()
     : discard_count_(0),
       recent_tab_discard_(false),
       discard_once_(false),
 #if !defined(OS_CHROMEOS)
       minimum_protection_time_(base::TimeDelta::FromMinutes(10)),
 #endif
       browser_tab_strip_tracker_(this, nullptr, nullptr),
       test_tick_clock_(nullptr),
-      under_memory_pressure_(false),
       weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   delegate_.reset(new TabManagerDelegate(weak_ptr_factory_.GetWeakPtr()));
 #endif
   browser_tab_strip_tracker_.Init();
-
-  // Set up default callbacks. These may be overridden post-construction as
-  // testing seams.
-  get_current_pressure_level_ = base::Bind(&GetCurrentPressureLevel);
-  notify_renderer_process_ = base::Bind(&NotifyRendererProcess);
 }
 
 TabManager::~TabManager() {
   Stop();
 }
 
 void TabManager::Start() {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   // Note that discarding is now enabled by default. This check is kept as a
   // kill switch.
@@ skipping 100 matching lines @@
 TabStatsList TabManager::GetTabStats() const {
   TabStatsList stats_list(GetUnsortedTabStats());
 
   // Sort the collected data so that least desirable to be killed is first, most
   // desirable is last.
   std::sort(stats_list.begin(), stats_list.end(), CompareTabStats);
 
   return stats_list;
 }
 
-std::vector<content::RenderProcessHost*>
-TabManager::GetOrderedRenderers() const {
-  // 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.
-    if (!seen_renderers.insert(renderer).second)
-      continue;
-
-    sorted_renderers.push_back(renderer);
-  }
-
-  return sorted_renderers;
-}
-
 bool TabManager::IsTabDiscarded(content::WebContents* contents) const {
   return GetWebContentsData(contents)->IsDiscarded();
 }
 
 bool TabManager::CanDiscardTab(int64_t target_web_contents_id) const {
   TabStripModel* model;
   int idx = FindTabStripModelById(target_web_contents_id, &model);
 
   if (idx == -1)
     return false;
@@ skipping 492 matching lines @@
 
   return null_contents;
 }
 
 void TabManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   // If Chrome is shutting down, do not do anything.
   if (g_browser_process->IsShuttingDown())
     return;
 
-  // If no task runner has been set, then use the same one that the memory
-  // pressure subsystem uses.
-  if (!task_runner_.get())
-    task_runner_ = base::ThreadTaskRunnerHandle::Get();
-
   // Under critical pressure try to discard a tab.
   if (memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     LogMemoryAndDiscardTab();
   }
   // TODO(skuhne): If more memory pressure levels are introduced, consider
   // calling PurgeBrowserMemory() before CRITICAL is reached.
-
-  // If this is the beginning of a period of memory pressure then kick off
-  // notification of child processes.
-  // NOTE: This mechanism relies on having a MemoryPressureMonitor
-  // implementation that supports "CurrentPressureLevel". This is true on all
-  // platforms on which TabManager is used.
-#if !defined(OS_CHROMEOS)
-  // Running GC under memory pressure can cause thrashing. Disable it on
-  // ChromeOS until the thrashing is fixed. crbug.com/588172.
-  if (!under_memory_pressure_)
-    DoChildProcessDispatch();
-#endif
 }
 
 void TabManager::TabChangedAt(content::WebContents* contents,
                               int index,
                               TabChangeType change_type) {
   if (change_type != TabChangeType::ALL)
     return;
   auto* data = GetWebContentsData(contents);
   bool old_state = data->IsRecentlyAudible();
   bool current_state = contents->WasRecentlyAudible();
@@ skipping 61 matching lines @@
   return web_contents_data;
 }
 
 TimeTicks TabManager::NowTicks() const {
   if (!test_tick_clock_)
     return TimeTicks::Now();
 
   return test_tick_clock_->NowTicks();
 }
 
-void TabManager::DoChildProcessDispatch() {
-  // If Chrome is shutting down, do not do anything.
-  if (g_browser_process->IsShuttingDown())
-    return;
-
-  if (!under_memory_pressure_)
-    under_memory_pressure_ = true;
-
-  // If the memory pressure condition has ended then stop dispatching messages.
-  auto level = get_current_pressure_level_.Run();
-  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 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)
-        continue;
-
-      // Notify the renderer.
-      notify_renderer_process_.Run(*rit, level);
-      notified = true;
-      break;
-    }
-
-    // If all renderers were processed and none were notified, then all
-    // renderers have already been notified. Clear the list and start again.
-    if (!notified)
-      notified_renderers_.clear();
-
-    // This loop can only run at most twice. If it doesn't exit the first time
-    // through, by the second time through |notified_renderers_| will be empty.
-    // Since |renderers| is always non-empty, the first renderer encountered
-    // during the second pass will be notified.
-  }
-
-  // Schedule another notification. Use a weak pointer so this doesn't explode
-  // during tear down.
-  task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::BindOnce(&TabManager::DoChildProcessDispatch,
-                     weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromSeconds(kRendererNotificationDelayInSeconds));
-}
-
 // TODO(jamescook): This should consider tabs with references to other tabs,
 // such as tabs created with JavaScript window.open(). Potentially consider
 // discarding the entire set together, or use that in the priority computation.
 content::WebContents* TabManager::DiscardTabImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats = GetTabStats();
 
   if (stats.empty())
     return nullptr;
   // Loop until a non-discarded tab to kill is found.
@@ skipping 20 matching lines @@
   // platform.
   std::string allow_multiple_discards = variations::GetVariationParamValue(
       features::kAutomaticTabDiscarding.name, "AllowMultipleDiscards");
   return (allow_multiple_discards != "true");
 #else
   return false;
 #endif
 }
 
 }  // namespace memory