Purge once random minutes(between 30min and 60min) after backgrounded.

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"
@@ skipping 40 matching lines @@
 // value.
 const int kAdjustmentIntervalSeconds = 10;
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
 // For each period of this length record a statistic to indicate whether or not
 // the user experienced a low memory event. If this interval is changed,
 // Tabs.Discard.DiscardInLastMinute must be replaced with a new statistic.
 const int kRecentTabDiscardIntervalSeconds = 60;
 #endif
 
-// If there has been no priority adjustment in this interval, assume the
-// machine was suspended and correct the timing statistics.
-const int kSuspendThresholdSeconds = kAdjustmentIntervalSeconds * 4;
-
-// A suspended renderer is suspended for this duration.
-constexpr base::TimeDelta kDurationOfRendererSuspension =
-    base::TimeDelta::FromSeconds(1200);
-
-// A resumed renderer is resumed for this duration.
-constexpr base::TimeDelta kDurationOfRendererResumption =
-    base::TimeDelta::FromSeconds(10);
+// The range between minimum and maximum time-to-purge.
+// The minimum time-to-purge is min_time_to_purge_ and its default value is
+// kDefaultMinTimeToPurge.
+// An inactive background tab's cache will be purged the time-to-purge
+// after the tab is backgrounded.
+const unsigned int kRangeBetweenMinAndMaxTimeToPurgeInMinutes = 30;
 
 // The time during which a tab is protected from discarding after it stops being
 // audible.
 const int kAudioProtectionTimeSeconds = 60;
 
 int FindTabStripModelById(int64_t target_web_contents_id,
                           TabStripModel** model) {
   DCHECK(model);
   for (auto* browser : *BrowserList::GetInstance()) {
     TabStripModel* local_model = browser->tab_strip_model();
@@ skipping 28 matching lines @@
     base::MemoryPressureListener::MemoryPressureLevel level) {
   content::MemoryPressureController::SendPressureNotification(
       render_process_host, level);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabManager
 
-constexpr base::TimeDelta TabManager::kDefaultTimeToFirstPurge;
+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),
@@ skipping 68 matching lines @@
     if (level == base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
       OnMemoryPressure(level);
     }
   }
 #endif
   // purge-and-suspend param is used for Purge+Suspend finch experiment
   // in the following way:
   // https://docs.google.com/document/d/1hPHkKtXXBTlsZx9s-9U17XC-ofEIzPo9FYbBEc7PPbk/edit?usp=sharing
   std::string purge_and_suspend_time = variations::GetVariationParamValue(
       "PurgeAndSuspend", "purge-and-suspend-time");
-  unsigned int time_to_first_purge_sec = 0;
+  unsigned int min_time_to_purge_sec = 0;
   if (purge_and_suspend_time.empty() ||
-      !base::StringToUint(purge_and_suspend_time, &time_to_first_purge_sec))
-    time_to_first_suspension_ = kDefaultTimeToFirstPurge;
+      !base::StringToUint(purge_and_suspend_time, &min_time_to_purge_sec))
+    min_time_to_purge_ = kDefaultMinTimeToPurge;
   else
-    time_to_first_suspension_ =
-        base::TimeDelta::FromSeconds(time_to_first_purge_sec);
+    min_time_to_purge_ = base::TimeDelta::FromSeconds(min_time_to_purge_sec);
 }
 
 void TabManager::Stop() {
   update_timer_.Stop();
   recent_tab_discard_timer_.Stop();
   memory_pressure_listener_.reset();
 }
 
 TabStatsList TabManager::GetTabStats() const {
   TabStatsList stats_list(GetUnsortedTabStats());
@@ skipping 198 matching lines @@
 content::WebContents* TabManager::GetWebContentsById(
     int64_t tab_contents_id) const {
   TabStripModel* model = nullptr;
   int index = FindTabStripModelById(tab_contents_id, &model);
   if (index == -1)
     return nullptr;
   return model->GetWebContentsAt(index);
 }
 
 bool TabManager::CanSuspendBackgroundedRenderer(int render_process_id) const {
-  // A renderer can be suspended if it's not playing media.
+  // A renderer can be purged if it's not playing media.
   auto tab_stats = GetUnsortedTabStats();
   for (auto& tab : tab_stats) {
     if (tab.child_process_host_id != render_process_id)
       continue;
     WebContents* web_contents = GetWebContentsById(tab.tab_contents_id);
     if (!web_contents)
       return false;
     if (IsMediaTab(web_contents))
       return false;
   }
@@ skipping 213 matching lines @@
       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. This function also tries to purge
-// cache memory and suspend tabs which becomes and keeps backgrounded for a
-// while.
+// cache memory.
 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();
+  PurgeBackgroundedTabsIfNeeded();
 }
 
-TabManager::PurgeAndSuspendState TabManager::GetNextPurgeAndSuspendState(
-    content::WebContents* content,
-    base::TimeTicks current_time,
-    const base::TimeDelta& time_to_first_suspension) const {
-  DCHECK(content);
-  PurgeAndSuspendState state =
-      GetWebContentsData(content)->GetPurgeAndSuspendState();
-
-  auto time_passed = current_time -
-      GetWebContentsData(content)->LastPurgeAndSuspendModifiedTime();
-  switch (state) {
-    case RUNNING:
-      if (time_passed > time_to_first_suspension)
-        return SUSPENDED;
-      break;
-    case RESUMED:
-      if (time_passed > kDurationOfRendererResumption)
-        return SUSPENDED;
-      break;
-    case SUSPENDED:
-      if (time_passed > kDurationOfRendererSuspension)
-        return RESUMED;
-      break;
-  }
-  return state;
+base::TimeDelta TabManager::GetTimeToPurge(
+    base::TimeDelta min_time_to_purge) const {
+  return min_time_to_purge + base::TimeDelta::FromMinutes(base::RandGenerator(
+                                 kRangeBetweenMinAndMaxTimeToPurgeInMinutes));
 }
 
-void TabManager::PurgeAndSuspendBackgroundedTabs() {
+bool TabManager::ShouldPurgeAtTime(content::WebContents* content,
+                                   base::TimeTicks current_time) const {
+  if (GetWebContentsData(content)->IsPurged())
+    return false;
+
+  base::TimeDelta time_passed =
+      current_time - GetWebContentsData(content)->LastInactiveTime();
+  return time_passed > GetWebContentsData(content)->TimeToPurge();
+}
+
+void TabManager::PurgeBackgroundedTabsIfNeeded() {
   base::TimeTicks current_time = NowTicks();
   auto tab_stats = GetUnsortedTabStats();
   for (auto& tab : tab_stats) {
     if (!tab.render_process_host->IsProcessBackgrounded())
       continue;
     if (!CanSuspendBackgroundedRenderer(tab.child_process_host_id))
       continue;
 
     WebContents* content = GetWebContentsById(tab.tab_contents_id);
     if (!content)
       continue;
 
-    PurgeAndSuspendState current_state =
-        GetWebContentsData(content)->GetPurgeAndSuspendState();
-    // If the tab's purge-and-suspend state is not RUNNING, the tab should be
-    // backgrounded. Since tab.last_hidden is updated everytime the tab is
-    // hidden, we should see tab.last_hidden < last_modified_time.
-    DCHECK(current_state == RUNNING ||
-           tab.last_hidden <
-               GetWebContentsData(content)->LastPurgeAndSuspendModifiedTime());
-    PurgeAndSuspendState next_state = GetNextPurgeAndSuspendState(
-        content, current_time, time_to_first_suspension_);
-    if (current_state == next_state)
+    bool purge_now = ShouldPurgeAtTime(content, current_time);
+    if (!purge_now)
       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.
-    GetWebContentsData(content)->SetPurgeAndSuspendState(next_state);
-    switch (next_state) {
-      case SUSPENDED:
-        tab.render_process_host->PurgeAndSuspend();
-        break;
-      case RESUMED:
-        tab.render_process_host->Resume();
-        break;
-      case RUNNING:
-        NOTREACHED();
-    }
+    GetWebContentsData(content)->SetPurgeState(true);
+    // TODO(tasak): rename PurgeAndSuspend with a better name, e.g.
+    // RequestPurgeCache, because we don't suspend any renderers.
+    tab.render_process_host->PurgeAndSuspend();
   }
 }
 
 WebContents* TabManager::DiscardWebContentsAt(int index, TabStripModel* model) {
   // Can't discard active index.
   if (model->active_index() == index)
     return nullptr;
 
   WebContents* old_contents = model->GetWebContentsAt(index);
 
@@ skipping 19 matching lines @@
   null_contents->SetLastActiveTime(old_contents->GetLastActiveTime());
   // Copy over the discard count.
   WebContentsData::CopyState(old_contents, null_contents);
 
   // Replace the discarded tab with the null version.
   model->ReplaceWebContentsAt(index, null_contents);
   // Mark the tab so it will reload when clicked on.
   GetWebContentsData(null_contents)->SetDiscardState(true);
   GetWebContentsData(null_contents)->IncrementDiscardCount();
 
+  // Make the tab PURGED to avoid purging null_contents.
+  GetWebContentsData(null_contents)->SetPurgeState(true);
+
   // Discard the old tab's renderer.
   // TODO(jamescook): This breaks script connections with other tabs.
   // Find a different approach that doesn't do that, perhaps based on navigation
   // to swappedout://.
   delete old_contents;
   recent_tab_discard_ = true;
 
   return null_contents;
 }
 
@@ skipping 41 matching lines @@
     data->SetRecentlyAudible(current_state);
     data->SetLastAudioChangeTime(NowTicks());
   }
 }
 
 void TabManager::ActiveTabChanged(content::WebContents* old_contents,
                                   content::WebContents* new_contents,
                                   int index,
                                   int reason) {
   GetWebContentsData(new_contents)->SetDiscardState(false);
-  GetWebContentsData(new_contents)->SetPurgeAndSuspendState(RUNNING);
+  GetWebContentsData(new_contents)->SetPurgeState(false);
   // If |old_contents| is set, that tab has switched from being active to
   // inactive, so record the time of that transition.
-  if (old_contents)
+  if (old_contents) {
     GetWebContentsData(old_contents)->SetLastInactiveTime(NowTicks());
+    // Re-setting time-to-purge every time a tab becomes inactive.
+    GetWebContentsData(old_contents)
+        ->SetTimeToPurge(GetTimeToPurge(min_time_to_purge_));
+  }
 }
 
 void TabManager::TabInsertedAt(TabStripModel* tab_strip_model,
                                content::WebContents* contents,
                                int index,
                                bool foreground) {
   // Only interested in background tabs, as foreground tabs get taken care of by
   // ActiveTabChanged.
   if (foreground)
     return;
 
   // A new background tab is similar to having a tab switch from being active to
   // inactive.
   GetWebContentsData(contents)->SetLastInactiveTime(NowTicks());
+  // Re-setting time-to-purge every time a tab becomes inactive.
+  GetWebContentsData(contents)->SetTimeToPurge(
+      GetTimeToPurge(min_time_to_purge_));
 }
 
 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 113 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