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

chrome/browser/memory/tab_manager_browsertest.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 "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 463 matching lines @@
   EXPECT_FALSE(tab_manager->DiscardTabImpl());
 
   // Reset auto-discardable state to true.
   tab_manager->SetTabAutoDiscardableState(tsm->GetWebContentsAt(0), true);
 
   // Now it should be able to discard the tab.
   EXPECT_TRUE(tab_manager->DiscardTabImpl());
   EXPECT_TRUE(tab_manager->IsTabDiscarded(tsm->GetWebContentsAt(0)));
 }
 
+IN_PROC_BROWSER_TEST_F(TabManagerTest, PurgeBackgroundRenderer) {
+  TabManager* tab_manager = g_browser_process->GetTabManager();
+
+  base::SimpleTestTickClock test_clock_;
+  tab_manager->set_test_tick_clock(&test_clock_);
+
+  // Get three tabs open.
+  content::WindowedNotificationObserver load1(
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::NotificationService::AllSources());
+  OpenURLParams open1(GURL(chrome::kChromeUIAboutURL), content::Referrer(),
+                      WindowOpenDisposition::CURRENT_TAB,
+                      ui::PAGE_TRANSITION_TYPED, false);
+  browser()->OpenURL(open1);
+  load1.Wait();
+
+  content::WindowedNotificationObserver load2(
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::NotificationService::AllSources());
+  OpenURLParams open2(GURL(chrome::kChromeUICreditsURL), content::Referrer(),
+                      WindowOpenDisposition::NEW_FOREGROUND_TAB,
+                      ui::PAGE_TRANSITION_TYPED, false);
+  browser()->OpenURL(open2);
+  load2.Wait();
+
+  content::WindowedNotificationObserver load3(
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::NotificationService::AllSources());
+  OpenURLParams open3(GURL(chrome::kChromeUITermsURL), content::Referrer(),
+                      WindowOpenDisposition::NEW_FOREGROUND_TAB,
+                      ui::PAGE_TRANSITION_TYPED, false);
+  browser()->OpenURL(open3);
+  load3.Wait();
+
+  auto* tsm = browser()->tab_strip_model();
+  TabManager::WebContentsData* tab1_contents_data =
+      tab_manager->GetWebContentsData(tsm->GetWebContentsAt(0));
+  TabManager::WebContentsData* tab2_contents_data =
+      tab_manager->GetWebContentsData(tsm->GetWebContentsAt(1));
+  TabManager::WebContentsData* tab3_contents_data =
+      tab_manager->GetWebContentsData(tsm->GetWebContentsAt(2));
+
+  // The time-to-purge initialized at ActiveTabChanged should be in the
+  // right default range.
+  EXPECT_GE(tab1_contents_data->time_to_purge(),
+            base::TimeDelta::FromMinutes(30));

[chrisha, 2017/03/15 17:42:41]

You should be referencing the class constants here so that this unittest doesn't
have to be manually updated if those constants change.

Also: please have a "min" and a "max" constant.

[tasak, 2017/03/16 04:39:48]

I know. What I really want to do here is that "manually updating the constants".
Because time-to-purge default value (kDefaultPurgeAndSuspendTime) was 30hours
(for about 3 months!) and no test covers.
If I use such kDefault... value here, I think, it is not able to see whether the
default value is wrong (e.g. 30 hours) or not.

+  EXPECT_LT(tab1_contents_data->time_to_purge(),
+            base::TimeDelta::FromMinutes(60));
+  EXPECT_GE(tab2_contents_data->time_to_purge(),
+            base::TimeDelta::FromMinutes(30));
+  EXPECT_LT(tab2_contents_data->time_to_purge(),
+            base::TimeDelta::FromMinutes(60));
+  EXPECT_GE(tab3_contents_data->time_to_purge(),
+            base::TimeDelta::FromMinutes(30));
+  EXPECT_LT(tab3_contents_data->time_to_purge(),
+            base::TimeDelta::FromMinutes(60));
+
+  // To make it easy to test, configure time-to-purge here.
+  base::TimeDelta time_to_purge1 = base::TimeDelta::FromMinutes(30);
+  base::TimeDelta time_to_purge2 = base::TimeDelta::FromMinutes(40);
+  tab1_contents_data->set_time_to_purge(time_to_purge1);
+  tab2_contents_data->set_time_to_purge(time_to_purge2);
+  tab3_contents_data->set_time_to_purge(time_to_purge1);
+
+  // No tabs are not purged yet.
+  ASSERT_FALSE(tab1_contents_data->is_purged());
+  ASSERT_FALSE(tab2_contents_data->is_purged());
+  ASSERT_FALSE(tab3_contents_data->is_purged());
+
+  // Advance the clock for time_to_purge1.
+  test_clock_.Advance(time_to_purge1);
+  tab_manager->PurgeBackgroundedTabsIfNeeded();
+
+  ASSERT_FALSE(tab1_contents_data->is_purged());
+  ASSERT_FALSE(tab2_contents_data->is_purged());
+  ASSERT_FALSE(tab3_contents_data->is_purged());
+
+  // Advance the clock for 1 minutes.
+  test_clock_.Advance(base::TimeDelta::FromMinutes(1));
+  tab_manager->PurgeBackgroundedTabsIfNeeded();
+
+  // Since tab1 is kept inactive and background for more than
+  // time_to_purge1, tab1 should be purged.
+  ASSERT_TRUE(tab1_contents_data->is_purged());
+  ASSERT_FALSE(tab2_contents_data->is_purged());
+  ASSERT_FALSE(tab3_contents_data->is_purged());
+
+  // Advance the clock.
+  test_clock_.Advance(time_to_purge2 - time_to_purge1);
+  tab_manager->PurgeBackgroundedTabsIfNeeded();
+
+  // Since tab2 is kept inactive and background for more than
+  // time_to_purge2, tab1 should be purged.
+  // Since tab3 is active, tab3 should not be purged.
+  ASSERT_TRUE(tab1_contents_data->is_purged());
+  ASSERT_TRUE(tab2_contents_data->is_purged());
+  ASSERT_FALSE(tab3_contents_data->is_purged());
+
+  tsm->CloseAllTabs();
+}
+
 }  // namespace memory
 
 #endif  // OS_WIN || OS_MAXOSX || OS_LINUX