[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.
 //
 // 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.

[Charlie Reis, 2017/06/10 00:53:36]

We should probably add a description of the new behavior being added.

[Zhen Wang, 2017/06/13 23:33:20]

Done.

 class TabManager : public TabStripModelObserver {
  public:
   // Needs to be public for DEFINE_WEB_CONTENTS_USER_DATA_KEY.
   class WebContentsData;
 
   TabManager();
   ~TabManager() override;
 
   // Number of discard events since Chrome started.
   int discard_count() const { return discard_count_; }
@@ skipping 64 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.

[Charlie Reis, 2017/06/10 00:53:36]

We may not need to expose this; see my question about the call site.

[Charlie Reis, 2017/07/06 23:50:30]

I'm still hoping we don't need this.  (See
https://codereview.chromium.org/2931023002/diff/1/chrome/browser/resource_coo...)

[Zhen Wang, 2017/07/07 18:06:39]

Now moved back to private as we do not need this URL check in throttle now.

+  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 throttled.
+  bool ShouldThrottleNavigation(

[nasko, 2017/06/12 23:22:02]

nit: s/Throttle/Delay/ as in this case we only care about delaying the
navigation for later.

[Zhen Wang, 2017/06/13 23:33:20]

Done.

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