Experimental 'purging and suspending' backgrounded tabs behind the flag

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 23 matching lines @@
 #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"
 
@@ skipping 423 matching lines @@
     bool is_active_window = browser->window()->IsActive();
     AddTabStats(browser->tab_strip_model(), browser->is_app(), is_active_window,
                 stats_list);
   }
 }
 
 void TabManager::AddTabStats(const TabStripModel* model,
                              bool is_app,
                              bool active_model,
                              TabStatsList* stats_list) {
-for (int i = 0; i < model->count(); i++) {
+  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_->GetCachedOomScore(stats.renderer_handle);
 #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.
+// updating on ChromeOS via the delegate. This function also tries to purge
+// cache memory and suspend tabs which becomes and keeps backgrounded for a
+// while.
 void TabManager::UpdateTimerCallback() {
   // If Chrome is shutting down, do not do anything.
   if (g_browser_process->IsShuttingDown())
     return;
 
   if (BrowserList::GetInstance()->empty())
     return;
 
   // Check for a discontinuity in time caused by the machine being suspended.
   if (!last_adjust_time_.is_null()) {
     TimeDelta suspend_time = NowTicks() - last_adjust_time_;
     if (suspend_time.InSeconds() > kSuspendThresholdSeconds) {
       // System was probably suspended, move the event timers forward in time so
       // when they get subtracted out later, "uptime" is being counted.
       start_time_ += suspend_time;
       if (!last_discard_time_.is_null())
         last_discard_time_ += suspend_time;
     }
   }
   last_adjust_time_ = NowTicks();
 
 #if defined(OS_CHROMEOS)
   TabStatsList stats_list = GetTabStats();
   // This starts the CrOS specific OOM adjustments in /proc/<pid>/oom_score_adj.
   delegate_->AdjustOomPriorities(stats_list);
 #endif
+
+  PurgeAndSuspendBackgroundedTabs();
+}
+
+void TabManager::PurgeAndSuspendBackgroundedTabs() {
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+  if (!command_line.HasSwitch(switches::kPurgeAndSuspendTime))
+    return;
+  int purge_and_suspend_time = 0;
+  if (!base::StringToInt(
+          command_line.GetSwitchValueASCII(switches::kPurgeAndSuspendTime),
+          &purge_and_suspend_time)) {
+    return;
+  }
+  if (purge_and_suspend_time <= 0)
+    return;
+  auto purge_and_suspend_time_threshold = NowTicks() -
+      base::TimeDelta::FromSeconds(purge_and_suspend_time);
+  auto tab_stats = GetUnsortedTabStats();
+  for (auto& tab : tab_stats) {
+    if (!tab.render_process_host->IsProcessBackgrounded())
+      continue;
+    // TODO(hajimehoshi): Now calling PurgeAndSuspend is implemented without
+    // timers for simplicity, so PurgeAndSuspend is called even after the
+    // renderer is purged and suspended once. This should be replaced with
+    // timers if we want necessary and sufficient signals.
+    if (tab.last_active > purge_and_suspend_time_threshold)
+      continue;
+    tab.render_process_host->PurgeAndSuspend();
+  }
 }
 
 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;
 
   WebContents* web_contents = model->GetWebContentsAt(idx);
@@ skipping 290 matching lines @@
     }
   } else {
     // The code here can only be tested under a full browser test.
     AddTabStats(&stats_list);
   }
 
   return stats_list;
 }
 
 }  // namespace memory