[TabManager] Move remaining discard logic from TabStripModel 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 <utility>
 #include <vector>
 
@@ skipping 32 matching lines @@
 // 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:
-  // TODO(georgesak): Make this private once all external dependencies are
-  // removed.
-  class WebContentsData;
-
   TabManager();
   ~TabManager() override;
 
   // Number of discard events since Chrome started.
   int discard_count() const { return discard_count_; }
 
   // See member comment.
   bool recent_tab_discard() const { return recent_tab_discard_; }
 
   // If |discard_once| is set, tabs that get discarded once will never get
   // discarded again.
   void Start(bool discard_once);
   void Stop();
 
   // Returns the list of the stats for all renderers. Must be called on the UI
   // thread.
   TabStatsList GetTabStats();
 
+  // Returns true if |contents| is currently discarded.
+  bool IsTabDiscarded(content::WebContents* contents) 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. Returns true if it
   // successfully found a tab and discarded it.
   bool DiscardTab();
 
   // Discards a tab with the given unique ID. The tab still exists in the
   // tab-strip; clicking on it will reload it. Returns true if it successfully
   // found a tab and discarded it.
   content::WebContents* DiscardTabById(int64 target_web_contents_id);
 
   // Log memory statistics for the running processes, then discards a tab.
   // Tab discard happens sometime later, as collecting the statistics touches
   // multiple threads and takes time.
   void LogMemoryAndDiscardTab();
 
   // Log memory statistics for the running processes, then call the callback.
   void LogMemory(const std::string& title, const base::Closure& callback);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, Comparator);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, DiscardedTabKeepsLastActiveTime);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, DiscardWebContentsAt);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, IsInternalPage);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, ReloadDiscardedTabContextMenu);
   FRIEND_TEST_ALL_PREFIXES(TabManagerTest, TabManagerBasics);
 
+  class WebContentsData;
+
   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 26 matching lines @@
   // Does the actual discard by destroying the WebContents in |model| at |index|
   // and replacing it by an empty one. Returns the new WebContents or NULL if
   // the operation fails (return value used only in testing).
   content::WebContents* DiscardWebContentsAt(int index, TabStripModel* model);
 
   // Called by the memory pressure listener when the memory pressure rises.
   void OnMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
   // TabStripModelObserver overrides.
+  void TabInsertedAt(content::WebContents* contents,
+                     int index,
+                     bool foreground) override;
   void TabChangedAt(content::WebContents* contents,
                     int index,
                     TabChangeType change_type) override;
+  void ActiveTabChanged(content::WebContents* old_contents,
+                        content::WebContents* new_contents,
+                        int index,
+                        int reason) override;
 
   // Returns true if the tab is currently playing audio or has played audio
   // recently.
   bool IsAudioTab(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 true if |first| is considered less desirable to be killed than
   // |second|.
   static bool CompareTabStats(TabStats first, TabStats second);
 
   // 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_;
@@ skipping 27 matching lines @@
 #endif
 
   BrowserTabStripTracker browser_tab_strip_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(TabManager);
 };
 
 }  // namespace memory
 
 #endif  // CHROME_BROWSER_MEMORY_TAB_MANAGER_H_