[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 <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/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/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 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)
 // 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:
   // Needs to be public for DEFINE_WEB_CONTENTS_USER_DATA_KEY.
   class WebContentsData;
 
   TabManager();
   ~TabManager() override;
@@ skipping 67 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 tab has finished loading. TabManager can
+  // decide which tab to load next.
+  void HasFinishedLoadingTab(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);
 
+  // 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);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, PurgeBackgroundRenderer);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ActivateTabResetPurgeState);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ShouldPurgeAtDefaultTime);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, DefaultTimeToPurgeInCorrectRange);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, AutoDiscardable);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, CanOnlyDiscardOnce);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ChildProcessNotifications);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, Comparator);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, DiscardedTabKeepsLastActiveTime);
@@ skipping 31 matching lines @@
   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);
 
   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();
 
   // Record whether an out of memory occured during a recent time interval. This
   // allows the normalization of low memory statistics versus usage.
   void RecordRecentTabDiscard();
 
   // Purges data structures in the browser that can be easily recomputed.
@@ skipping 73 matching lines @@
   // for more details.
   base::TimeTicks NowTicks() const;
 
   // 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;
 
+  // Returns true if the navigation should be delay.

[chrisha, 2017/06/15 21:02:24]

delayed*

[Zhen Wang, 2017/06/19 23:00:12]

Done.

+  bool ShouldDelayNavigation(
+      content::NavigationHandle* navigation_handle) const;
+
+  // Resume the tab's navigation if it is pending right now.
+  void ResumeTabNavigationIfNeeded(content::WebContents* contents);
+
   // 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 43 matching lines @@
   // 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_;
 
+  // The list of navigation handles that are throttled.
+  std::vector<content::NavigationHandle*> pending_navigations_;
+
+  // The tab that is currently loading. If multiple tabs are loading
+  // simultaneously, it corresponds to the lastest one. We will consider loading
+  // the next background tab when this tab has finished loading.
+  // TODO(zhenw): This is a native algorithm. It should be updated to use

[nasko, 2017/06/15 20:01:58]

nit: Did you mean "naive" instead of "native"?

[Zhen Wang, 2017/06/19 23:00:12]

Right. Updated to naive. Thanks for catching this!

+  // smarter ways, e.g., making sure all loading tabs have finished.
+  content::WebContents* loading_contents_;

[chrisha, 2017/06/15 21:02:24]

We have loading states being worked on in another CL. This is duplicating some
of that effort (ie, the HasFinishedLoadingTab), and maybe these CLs should be
stacked?

I think we need to maintain a few lists of tabs internally, and manage
transitions of tabs between these states (or decorate each webcontents with the
state...)

pending_load (background tab opening, session restore created, mass bookmark
folder opening, etc)
loading
loaded
discarded

(We'll have to add other states as lifecycles come online)

[Zhen Wang, 2017/06/19 23:00:12]

Now I have rebased this CL on the other CL and I changed this to a list to track
all currently loading tabs. We can add other lists gradually later.

[chrisha, 2017/06/20 18:26:54]

sgtm

+
   // 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_