Provide renderers with memory pressure signals.

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 "ash/multi_profile_uma.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #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.h"
 #include "base/process/process.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/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/tick_clock.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/memory/oom_memory_details.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_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/host_desktop.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/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 "chrome/browser/memory/tab_manager_delegate_chromeos.h"
 #endif
 
 using base::TimeDelta;
@@ skipping 39 matching lines @@
       if (web_contents_id == target_web_contents_id) {
         *model = local_model;
         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
 
 TabManager::TabManager()
     : discard_count_(0),
       recent_tab_discard_(false),
       discard_once_(false),
       browser_tab_strip_tracker_(this, nullptr, nullptr),
-      test_tick_clock_(nullptr) {
+      test_tick_clock_(nullptr),
+      under_memory_pressure_(false),
+      weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   delegate_.reset(new TabManagerDelegate);
 #endif
   browser_tab_strip_tracker_.Init(
       BrowserTabStripTracker::InitWith::ALL_BROWERS);
+
+  // 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)
   // If the feature is not enabled, do nothing.
   if (!base::FeatureList::IsEnabled(features::kAutomaticTabDiscarding))
@@ skipping 60 matching lines @@
 }
 
 // Things to collect on the browser thread (because TabStripModel isn't thread
 // safe):
 // 1) whether or not a tab is pinned
 // 2) last time a tab was selected
 // 3) is the tab currently selected
 TabStatsList TabManager::GetTabStats() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats_list;
-  stats_list.reserve(32);  // 99% of users have < 30 tabs open
+  stats_list.reserve(32);  // 99% of users have < 30 tabs open.
 
-  // Go through each window to get all the tabs.
-  AddTabStats(&stats_list);
+  // TODO(chrisha): Move this code to a TabStripModel enumeration delegate!
+  if (!test_tab_strip_models_.empty()) {
+    for (size_t i = 0; i < test_tab_strip_models_.size(); ++i) {
+      AddTabStats(test_tab_strip_models_[i].first,   // tab_strip_model
+                  test_tab_strip_models_[i].second,  // is_app
+                  i == 0,                            // is_active
+                  &stats_list);
+    }
+  } else {
+    // The code here can only be tested under a full browser test.
+    AddTabStats(&stats_list);
+  }
 
   // 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() {
+  // Get the tab stats.
+  auto tab_stats = GetTabStats();
+
+  std::vector<content::RenderProcessHost*> sorted_renderers;
+  std::set<content::RenderProcessHost*> seen_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) {
+    // 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 {
   return GetWebContentsData(contents)->IsDiscarded();
 }
 
 // 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.
 bool TabManager::DiscardTab() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats = GetTabStats();
@@ skipping 173 matching lines @@
 
 void TabManager::AddTabStats(TabStatsList* stats_list) {
   BrowserList* browser_list = BrowserList::GetInstance();
   // The first window will be the active one.
   bool browser_active = true;
   for (BrowserList::const_reverse_iterator browser_iterator =
            browser_list->begin_last_active();
        browser_iterator != browser_list->end_last_active();
        ++browser_iterator) {
     Browser* browser = *browser_iterator;
-    bool is_browser_for_app = browser->is_app();
-    const TabStripModel* model = browser->tab_strip_model();
-    for (int i = 0; i < model->count(); i++) {
-      WebContents* contents = model->GetWebContentsAt(i);
-      if (!contents->IsCrashed()) {
-        TabStats stats;
-        stats.is_app = is_browser_for_app;
-        stats.is_internal_page =
-            IsInternalPage(contents->GetLastCommittedURL());
-        stats.is_media = IsMediaTab(contents);
-        stats.is_pinned = model->IsTabPinned(i);
-        stats.is_selected = browser_active && model->IsTabSelected(i);
-        stats.is_discarded = GetWebContentsData(contents)->IsDiscarded();
-        stats.has_form_entry =
-            contents->GetPageImportanceSignals().had_form_interaction;
-        stats.discard_count = GetWebContentsData(contents)->DiscardCount();
-        stats.last_active = contents->GetLastActiveTime();
-        stats.renderer_handle = contents->GetRenderProcessHost()->GetHandle();
-        stats.child_process_host_id = contents->GetRenderProcessHost()->GetID();
-#if defined(OS_CHROMEOS)
-        stats.oom_score = delegate_->GetOomScore(stats.child_process_host_id);
-#endif
-        stats.title = contents->GetTitle();
-        stats.tab_contents_id = IdFromWebContents(contents);
-        stats_list->push_back(stats);
-      }
-    }
+    AddTabStats(browser->tab_strip_model(), browser->is_app(), browser_active,
+                stats_list);
     // The active browser window is processed in the first iteration.
     browser_active = false;
   }
 }
 
+void TabManager::AddTabStats(const TabStripModel* model,
+                             bool is_app,
+                             bool active_model,
+                             TabStatsList* stats_list) {
+for (int i = 0; i < model->count(); i++) {
+    WebContents* contents = model->GetWebContentsAt(i);
+    if (!contents->IsCrashed()) {
+      TabStats stats;
+      stats.is_app = is_app;
+      stats.is_internal_page =
+          IsInternalPage(contents->GetLastCommittedURL());
+      stats.is_media = IsMediaTab(contents);
+      stats.is_pinned = model->IsTabPinned(i);
+      stats.is_selected = active_model && model->IsTabSelected(i);
+      stats.is_discarded = GetWebContentsData(contents)->IsDiscarded();
+      stats.has_form_entry =
+          contents->GetPageImportanceSignals().had_form_interaction;
+      stats.discard_count = GetWebContentsData(contents)->DiscardCount();
+      stats.last_active = contents->GetLastActiveTime();
+      stats.render_process_host = contents->GetRenderProcessHost();
+      stats.renderer_handle = contents->GetRenderProcessHost()->GetHandle();
+      stats.child_process_host_id = contents->GetRenderProcessHost()->GetID();
+#if defined(OS_CHROMEOS)
+      stats.oom_score = delegate_->GetOomScore(stats.child_process_host_id);
+#endif
+      stats.title = contents->GetTitle();
+      stats.tab_contents_id = IdFromWebContents(contents);
+      stats_list->push_back(stats);
+    }
+  }
+}
+
 // This function is called when |update_timer_| fires. It will adjust the clock
 // if needed (if it detects that the machine was asleep) and will fire the stats
 // updating on ChromeOS via the delegate.
 void TabManager::UpdateTimerCallback() {
   // If Chrome is shutting down, do not do anything.
   if (g_browser_process->IsShuttingDown())
     return;
 
   if (BrowserList::GetInstance()->empty())
     return;
@@ skipping 115 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;
 
-  // For the moment only do something when critical state is reached.
+  // 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 (!under_memory_pressure_)
+    DoChildProcessDispatch();
 }
 
 bool TabManager::IsMediaTab(WebContents* contents) const {
   if (contents->WasRecentlyAudible())
     return true;
 
   scoped_refptr<MediaStreamCaptureIndicator> media_indicator =
       MediaCaptureDevicesDispatcher::GetInstance()
           ->GetMediaStreamCaptureIndicator();
   if (media_indicator->IsCapturingUserMedia(contents) ||
@@ skipping 53 matching lines @@
   return first.last_active > second.last_active;
 }
 
 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 (however unlikely) for no renderers to exist, 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::Bind(&TabManager::DoChildProcessDispatch,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromSeconds(kRendererNotificationDelayInSeconds));
+}
+
 }  // namespace memory