Move responsiblity of tab suspending from renderer to TabManager

chrome/browser/memory/tab_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEMORY_TAB_MANAGER_H_
 #define CHROME_BROWSER_MEMORY_TAB_MANAGER_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 36 matching lines @@
 #endif
 
 // The TabManager periodically updates (see
 // |kAdjustmentIntervalSeconds| in the source) the status of renderers
 // which are then used by the algorithm embedded here for priority in being
 // killed upon OOM conditions.
 //
 // The algorithm used favors killing tabs that are not selected, not pinned,
 // and have been idle for longest, in that order of priority.
 //
 // On Chrome OS (via the delegate), the kernel (via /proc/<pid>/oom_score_adj)

[Georges Khalil, 2016/04/19 13:55:19]

Add a mention here about what we do on Android.

 // will be informed of each renderer's score, which is based on the status, so
 // in case Chrome is not able to relieve the pressure quickly enough and the
 // kernel is forced to kill processes, it will be able to do so using the same
 // algorithm as the one used here.
 //
 // Note that the browser tests are only active for platforms that use
 // TabManager (CrOS only for now) and need to be adjusted accordingly if
 // support for new platforms is added.
 class TabManager : public TabStripModelObserver {
  public:
@@ skipping 70 matching lines @@
   // NOTE: This value needs to be big enough to allow a process to get over the
   // hump in responding to memory pressure, so there aren't multiple processes
   // fighting for CPU and worse, temporary memory, while trying to free things
   // up. Similarly, it shouldn't be too large otherwise it will take too long
   // for the entire system to respond. Ideally, there would be a callback from a
   // child process indicating that the message has been handled. In the meantime
   // this is chosen to be sufficient to allow a worst-case V8+Oilpan GC to run,
   // with a little slop.
   enum : int { kRendererNotificationDelayInSeconds = 2 };
 
+  enum : int { kSuspendTimersWhenBackgroundedDelayInSeconds = 5 * 60 };
+
   using MemoryPressureLevel = base::MemoryPressureListener::MemoryPressureLevel;
 
   // A callback that returns the current memory pressure level.
   using MemoryPressureLevelCallback = base::Callback<MemoryPressureLevel()>;
 
   // Callback that notifies a |renderer| of the memory pressure at a given
   // |level|. Provides a testing seam.
   using RendererNotificationCallback = base::Callback<
       void(const content::RenderProcessHost* /* renderer */,
            MemoryPressureLevel /* level */)>;
@@ skipping 165 matching lines @@
 
   // Weak pointer factory used for posting delayed tasks to task_runner_.
   base::WeakPtrFactory<TabManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabManager);
 };
 
 }  // namespace memory
 
 #endif  // CHROME_BROWSER_MEMORY_TAB_MANAGER_H_