[TooManyTabs] Add TabNavigationThrottle

chrome/browser/resource_coordinator/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_RESOURCE_COORDINATOR_TAB_MANAGER_H_
 #define CHROME_BROWSER_RESOURCE_COORDINATOR_TAB_MANAGER_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #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/timer/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/resource_coordinator/tab_manager_observer.h"
 #include "chrome/browser/resource_coordinator/tab_stats.h"
 #include "chrome/browser/sessions/session_restore_observer.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/browser_tab_strip_tracker.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
+#include "content/public/browser/navigation_throttle.h"
 
 class BrowserList;
 class GURL;
 class TabStripModel;
 
 namespace base {
 class TickClock;
 }
 
 namespace content {
+class NavigationHandle;
 class WebContents;
 }
 
 namespace resource_coordinator {
 
 #if defined(OS_CHROMEOS)
 class TabManagerDelegate;
 #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 active, not in an active
 // window, not in a visible window, 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)
 // 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.
 //
+// The TabManager also delays background tabs' navigation when needed in order
+// to improve users' experience with the foreground tab.
+//
 // 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 chrome::BrowserListObserver {
  public:
   // Needs to be public for DEFINE_WEB_CONTENTS_USER_DATA_KEY.
   class WebContentsData;
 
   TabManager();
@@ skipping 69 matching lines @@
   bool IsTabAutoDiscardable(content::WebContents* contents) const;
 
   // Sets/clears the auto-discardable state of the tab.
   void SetTabAutoDiscardableState(content::WebContents* contents, bool state);
 
   // Returns true when a given renderer can be purged if the specified
   // renderer is eligible for purging.
   // TODO(tasak): rename this to CanPurgeBackgroundedRenderer.
   bool CanSuspendBackgroundedRenderer(int render_process_id) const;
 
+  // Maybe throttle a tab's navigation based on current system status.
+  content::NavigationThrottle::ThrottleCheckResult MaybeThrottleNavigation(
+      content::NavigationHandle* navigation_handle);
+
+  // Notifies TabManager that one navigation has finished (committed, aborted or
+  // replaced). TabManager should clean up the NavigationHandle objects bookkept
+  // before.
+  void OnDidFinishNavigation(content::NavigationHandle* navigation_handle);
+
+  // Notifies TabManager that one tab has finished loading. TabManager can
+  // decide which tab to load next.
+  void OnDidStopLoading(content::WebContents* contents);
+
+  // Notifies TabManager that one tab WebContents has been destroyed. TabManager
+  // needs to clean up data related to that tab.
+  void OnWebContentsDestroyed(content::WebContents* contents);
+
   // Returns true if |first| is considered less desirable to be killed than
   // |second|.
   static bool CompareTabStats(const TabStats& first, const TabStats& second);
 
   // Returns a unique ID for a WebContents. Do not cast back to a pointer, as
   // the WebContents could be deleted if the user closed the tab.
   static int64_t IdFromWebContents(content::WebContents* web_contents);
 
   // Return whether tabs are being loaded during session restore.
   bool IsSessionRestoreLoadingTabs() const {
@@ skipping 17 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ProtectPDFPages);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ProtectRecentlyUsedTabs);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ProtectVideoTabs);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ReloadDiscardedTabContextMenu);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, TabManagerBasics);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, FastShutdownSingleTabProcess);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest,
                            GetUnsortedTabStatsIsInVisibleWindow);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, HistogramsSessionRestoreSwitchToTab);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, DiscardTabWithNonVisibleTabs);
+  FRIEND_TEST_ALL_PREFIXES(TabManagerTest, MaybeThrottleNavigation);
+  FRIEND_TEST_ALL_PREFIXES(TabManagerTest, OnDidFinishNavigation);
+  FRIEND_TEST_ALL_PREFIXES(TabManagerTest, OnDidStopLoading);
+  FRIEND_TEST_ALL_PREFIXES(TabManagerTest, OnWebContentsDestroyed);
+  FRIEND_TEST_ALL_PREFIXES(TabManagerTest, OnDelayedTabSelected);
 
   // Information about a Browser.
   struct BrowserInfo {
     TabStripModel* tab_strip_model;
     bool window_is_minimized;
     bool browser_is_app;
   };
 
   // The time of the first purging after a renderer is backgrounded.
   // The initial value was chosen because most of users activate backgrounded
@@ skipping 132 matching lines @@
   // corresponds to the last active Browser.
   std::vector<BrowserInfo> GetBrowserInfoList() const;
 
   void OnSessionRestoreStartedLoadingTabs();
   void OnSessionRestoreFinishedLoadingTabs();
 
   // Records UMA histograms for the tab state when switching to a different tab
   // during session restore.
   void RecordSwitchToTab(content::WebContents* contents) const;
 
+  // Returns true if the navigation should be delayed.
+  bool ShouldDelayNavigation(
+      content::NavigationHandle* navigation_handle) const;
+
+  // Start loading the next background tab if needed.
+  void LoadNextBackgroundTabIfNeeded();
+
+  // Resume the tab's navigation if it is pending right now.
+  void ResumeTabNavigationIfNeeded(content::WebContents* contents);
+
+  // Resume navigation.
+  void ResumeNavigation(content::NavigationHandle* navigation_handle);
+
+  // Remove the pending navigation for the provided WebContents. Return the
+  // removed navigation handle. Return nullptr if it doesn't exists.
+  content::NavigationHandle* RemovePendingNavigationIfNeeded(
+      content::WebContents* contents);
+
+  // Check if the tab is loading. Use only in tests.
+  bool IsTabLoadingForTest(content::WebContents* contents) const;
+
+  // Check if the navigation is delayed. Use only in tests.
+  bool IsNavigationDelayedForTest(
+      const content::NavigationHandle* navigation_handle) const;
+
   // Timer to periodically update the stats of the renderers.
   base::RepeatingTimer update_timer_;
 
   // Timer to periodically report whether a tab has been discarded since the
   // last time the timer has fired.
   base::RepeatingTimer recent_tab_discard_timer_;
 
   // A listener to global memory pressure events.
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 
@@ skipping 49 matching lines @@
   std::vector<BrowserInfo> test_browser_info_list_;
 
   // List of observers that will receive notifications on state changes.
   base::ObserverList<TabManagerObserver> observers_;
 
   bool is_session_restore_loading_tabs_;
 
   class TabManagerSessionRestoreObserver;
   std::unique_ptr<TabManagerSessionRestoreObserver> session_restore_observer_;
 
+  // The list of navigation handles that are delayed.
+  std::vector<content::NavigationHandle*> pending_navigations_;
+
+  // The tabs that are currently loading. We will consider loading the next
+  // background tab when these tabs have finished loading or a background tab
+  // is brought to foreground.
+  std::set<content::WebContents*> loading_contents_;
+
   // Weak pointer factory used for posting delayed tasks.
   base::WeakPtrFactory<TabManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabManager);
 };
 
 }  // namespace resource_coordinator
 
 #endif  // CHROME_BROWSER_RESOURCE_COORDINATOR_TAB_MANAGER_H_