Make purge-and-suspend-time finch experiment parameter

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 203 matching lines @@
   if (monitor) {
     memory_pressure_listener_.reset(new base::MemoryPressureListener(
         base::Bind(&TabManager::OnMemoryPressure, base::Unretained(this))));
     base::MemoryPressureListener::MemoryPressureLevel level =
         monitor->GetCurrentPressureLevel();
     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 time_to_first_suspension_sec;
+  if (purge_and_suspend_time.empty() ||
+      !base::StringToUint(purge_and_suspend_time,
+                          &time_to_first_suspension_sec))
+    time_to_first_suspension_sec = 108000;

[Wez, 2017/02/15 22:22:52]

There doesn't seem to be any explanation here, or in the linked document, of why
30 hours is a good time-to-first-suspension?

+  time_to_first_suspension_ =
+      base::TimeDelta::FromSeconds(time_to_first_suspension_sec);
 }
 
 void TabManager::Stop() {
   update_timer_.Stop();
   recent_tab_discard_timer_.Stop();
   memory_pressure_listener_.reset();
 }
 
 TabStatsList TabManager::GetTabStats() {
   TabStatsList stats_list(GetUnsortedTabStats());
@@ skipping 490 matching lines @@
       break;
     case SUSPENDED:
       if (time_passed > kDurationOfRendererSuspension)
         return RESUMED;
       break;
   }
   return state;
 }
 
 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;
   base::TimeTicks current_time = NowTicks();
-  base::TimeDelta time_to_first_suspension =
-      base::TimeDelta::FromSeconds(purge_and_suspend_time);
   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);
+        content, current_time, time_to_first_suspension_);
     if (current_state == next_state)
       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:
@@ skipping 250 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