[TabManager] Start function refactoring.

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 147 matching lines @@
 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))
     return;
 
-  // Check the variation parameter to see if a tab be discarded more than once.
-  // Default is to only discard once per tab.
-  std::string allow_multiple_discards = variations::GetVariationParamValue(
-      features::kAutomaticTabDiscarding.name, "AllowMultipleDiscards");
-  if (allow_multiple_discards == "true")
-    discard_once_ = false;
-  else
-    discard_once_ = true;
-
   // Check the variation parameter to see if a tab is to be protected for an
   // amount of time after being backgrounded. The value is in seconds.
   std::string minimum_protection_time_string =
       variations::GetVariationParamValue(features::kAutomaticTabDiscarding.name,
                                          "MinimumProtectionTime");
   if (!minimum_protection_time_string.empty()) {
     unsigned int minimum_protection_time_seconds = 0;
     if (base::StringToUint(minimum_protection_time_string,
                            &minimum_protection_time_seconds)) {
       if (minimum_protection_time_seconds > 0)
         minimum_protection_time_ =
             base::TimeDelta::FromSeconds(minimum_protection_time_seconds);
     }
   }
+#endif
 
-#elif defined(OS_CHROMEOS)
-  // On Chrome OS, tab manager is always started and tabs can be discarded more
-  // than once.
-  discard_once_ = false;
-#endif
+  // Check if only one discard is allowed.
+  discard_once_ = CanOnlyDiscardOnce();
 
   if (!update_timer_.IsRunning()) {
     update_timer_.Start(FROM_HERE,
                         TimeDelta::FromSeconds(kAdjustmentIntervalSeconds),
                         this, &TabManager::UpdateTimerCallback);
   }
 
   // MemoryPressureMonitor is not implemented on Linux so far and tabs are never
   // discarded.
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
@@ skipping 347 matching lines @@
   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 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;
@@ skipping 275 matching lines @@
   for (TabStatsList::const_reverse_iterator stats_rit = stats.rbegin();
        stats_rit != stats.rend(); ++stats_rit) {
     int64_t least_important_tab_id = stats_rit->tab_contents_id;
     if (CanDiscardTab(least_important_tab_id) &&
         DiscardTabById(least_important_tab_id))
       return true;
   }
   return false;
 }
 
+// Check the variation parameter to see if a tab can be discarded only once or
+// multiple times.
+// Default is to only discard once per tab.
+bool TabManager::CanOnlyDiscardOnce() {
+#if defined(OS_WIN) || defined(OS_MACOSX)
+  // On Windows and MacOS, default to discarding only once unless otherwise
+  // specified by the variation parameter.
+  // TODO(georgesak): add condition for linux when TabManager is supported.

[Georges Khalil, 2016/05/17 18:43:16]

nit: change this comment to
Add Linux when automatic discarding is enabled for that platform.

[Anderson Silva, 2016/05/17 18:50:30]

Acknowledged.

+  std::string allow_multiple_discards = variations::GetVariationParamValue(
+      features::kAutomaticTabDiscarding.name, "AllowMultipleDiscards");
+  return (allow_multiple_discards != "true");
+#else
+  return false;
+#endif
+}
+
 // 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::GetUnsortedTabStats() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats_list;
   stats_list.reserve(32);  // 99% of users have < 30 tabs open.
 
   // 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);
   }
 
   return stats_list;
 }
 
 }  // namespace memory