Remove renderer notifications of memory pressure.

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>
-#include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
-#include "base/task_runner.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/memory/tab_manager_observer.h"
 #include "chrome/browser/memory/tab_stats.h"
 #include "chrome/browser/ui/browser_tab_strip_tracker.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 
 class BrowserList;
 class GURL;
 class TabStripModel;
 
 namespace base {
 class TickClock;
 }
 
 namespace content {
-class RenderProcessHost;
 class WebContents;
 }
 
 namespace memory {
 
 #if defined(OS_CHROMEOS)
 class TabManagerDelegate;
 #endif
 
 // The TabManager periodically updates (see
@@ skipping 28 matching lines @@
   bool recent_tab_discard() const { return recent_tab_discard_; }
 
   // Start/Stop the Tab Manager.
   void Start();
   void Stop();
 
   // Returns the list of the stats for all renderers. Must be called on the UI
   // thread. The returned list is sorted by reversed importance.
   TabStatsList GetTabStats() const;
 
-  // Returns a sorted list of renderers, from most important to least important.
-  std::vector<content::RenderProcessHost*> GetOrderedRenderers() const;
-
   // Returns true if |contents| is currently discarded.
   bool IsTabDiscarded(content::WebContents* contents) const;
 
   // Goes through a list of checks to see if a tab is allowed to be discarded by
   // the automatic tab discarding mechanism. Note that this is not used when
   // discarding a particular tab from about:discards.
   bool CanDiscardTab(int64_t target_web_contents_id) const;
 
   // Discards a tab to free the memory occupied by its renderer. The tab still
   // exists in the tab-strip; clicking on it will reload it.
@@ skipping 99 matching lines @@
   // Called by WebContentsData whenever the discard state of a WebContents
   // changes, so that observers can be informed.
   void OnDiscardedStateChange(content::WebContents* contents,
                               bool is_discarded);
 
   // Called by WebContentsData whenever the auto-discardable state of a
   // WebContents changes, so that observers can be informed.
   void OnAutoDiscardableStateChange(content::WebContents* contents,
                                     bool is_auto_discardable);
 
-  // The time that a renderer is given to react to a memory pressure
-  // notification before another renderer is also notified. This prevents all
-  // renderers from receiving and acting upon notifications simultaneously,
-  // which can quickly overload a system. Exposed for unittesting.
-  // 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 };
-
-  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 */)>;
-
   static void PurgeMemoryAndDiscardTab();
 
   // Returns true if the |url| represents an internal Chrome web UI page that
   // can be easily reloaded and hence makes a good choice to discard.
   static bool IsInternalPage(const GURL& url);
 
   // Records UMA histogram statistics for a tab discard. Record statistics for
   // user triggered discards via chrome://discards/ because that allows to
   // manually test the system.
   void RecordDiscardStatistics();
@@ skipping 72 matching lines @@
   bool IsMediaTab(content::WebContents* contents) const;
 
   // Returns the WebContentsData associated with |contents|. Also takes care of
   // creating one if needed.
   WebContentsData* GetWebContentsData(content::WebContents* contents) const;
 
   // Returns either the system's clock or the test clock. See |test_tick_clock_|
   // for more details.
   base::TimeTicks NowTicks() const;
 
-  // Dispatches a memory pressure message to a single child process, and
-  // schedules another call to itself as long as memory pressure continues.
-  void DoChildProcessDispatch();
-
   // Implementation of DiscardTab. Returns null if no tab was discarded.
   // Otherwise returns the new web_contents of the discarded tab.
   content::WebContents* DiscardTabImpl();
 
   // Returns true if tabs can be discarded only once.
   bool CanOnlyDiscardOnce() const;
 
   // Timer to periodically update the stats of the renderers.
   base::RepeatingTimer update_timer_;
 
@@ skipping 37 matching lines @@
 #endif
 
   // Responsible for automatically registering this class as an observer of all
   // TabStripModels. Automatically tracks browsers as they come and go.
   BrowserTabStripTracker browser_tab_strip_tracker_;
 
   // Pointer to a test clock. If this is set, NowTicks() returns the value of
   // this test clock. Otherwise it returns the system clock's value.
   base::TickClock* test_tick_clock_;
 
-  // The task runner used for child process notifications. Defaults to the
-  // thread task runner handle that is used by the memory pressure subsystem,
-  // but may be explicitly set for unittesting.
-  scoped_refptr<base::TaskRunner> task_runner_;
-
-  // Indicates that the system is currently experiencing memory pressure. Used
-  // to determine whether a new round of child-process memory pressure
-  // dispatches is starting, or whether an existing one is continuing.
-  bool under_memory_pressure_;
-
-  // The set of child renderers that have received memory pressure notifications
-  // during the current bout of memory pressure. This is emptied when all
-  // children have been notified (restarting another round of notification) and
-  // when a bout of memory pressure ends.
-  std::set<const content::RenderProcessHost*> notified_renderers_;
-
-  // The callback that returns the current memory pressure level. Defaults to
-  // querying base::MemoryPressureMonitor, but can be overridden for testing.
-  MemoryPressureLevelCallback get_current_pressure_level_;
-
-  // The callback to be invoked to notify renderers. Defaults to calling
-  // content::SendPressureNotification, but can be overridden for testing.
-  RendererNotificationCallback notify_renderer_process_;
-
   // Injected tab strip models. Allows this to be tested end-to-end without
   // requiring a full browser environment. If specified these tab strips will be
   // crawled as the authoritative source of tabs, otherwise the BrowserList and
   // associated Browser objects are crawled. The first of these is considered to
   // be the 'active' tab strip model.
   // TODO(chrisha): Factor out tab-strip model enumeration to a helper class,
   //     and make a delegate that centralizes all testing seams.
   using TestTabStripModel = std::pair<const TabStripModel*, bool>;
   std::vector<TestTabStripModel> test_tab_strip_models_;
 
   // List of observers that will receive notifications on state changes.
   base::ObserverList<TabManagerObserver> observers_;
 
-  // Weak pointer factory used for posting delayed tasks to task_runner_.
+  // Weak pointer factory used for posting delayed tasks.
   base::WeakPtrFactory<TabManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabManager);
 };
 
 }  // namespace memory
 
 #endif  // CHROME_BROWSER_MEMORY_TAB_MANAGER_H_