[TabManager] Move remaining discard logic from TabStripModel to TabManager.

chrome/browser/memory/tab_manager.cc

 // 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.
 
 #include "chrome/browser/memory/tab_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 162 matching lines @@
     AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH), false,
                 &stats_list);
   }
 
   // Sort the collected data so that least desirable to be killed is first, most
   // desirable is last.
   std::sort(stats_list.begin(), stats_list.end(), CompareTabStats);
   return stats_list;
 }
 
+bool TabManager::IsTabDiscarded(content::WebContents* contents) const {
+  return GetWebContentsData(contents)->IsDiscarded();
+}
+
 // TODO(jamescook): This should consider tabs with references to other tabs,
 // such as tabs created with JavaScript window.open(). Potentially consider
 // discarding the entire set together, or use that in the priority computation.
 bool TabManager::DiscardTab() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats = GetTabStats();
   if (stats.empty())
     return false;
   // Loop until a non-discarded tab to kill is found.
   for (TabStatsList::const_reverse_iterator stats_rit = stats.rbegin();
@@ skipping 22 matching lines @@
   LogMemory("Tab Discards Memory details",
             base::Bind(&TabManager::PurgeMemoryAndDiscardTab));
 }
 
 void TabManager::LogMemory(const std::string& title,
                            const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OomMemoryDetails::Log(title, callback);
 }
 
+void TabManager::TabInsertedAt(content::WebContents* contents,
+                               int index,
+                               bool foreground) {
+  WebContentsData::CreateForWebContents(contents);

[sky, 2015/10/27 21:16:46]

Is this necessary? Doesn't GetWebContentsData() implicitly create?

[Georges Khalil, 2015/10/30 14:17:44]

Correct, this is not needed. Removed.

+}
+
 void TabManager::TabChangedAt(content::WebContents* contents,
                               int index,
                               TabChangeType change_type) {
+  WebContentsData::CreateForWebContents(contents);
   if (change_type != TabChangeType::ALL)
     return;
-
-  bool old_state = WebContentsData::IsRecentlyAudible(contents);
+  auto data = GetWebContentsData(contents);
+  bool old_state = data->IsRecentlyAudible();
   bool current_state = contents->WasRecentlyAudible();
   if (old_state != current_state) {
-    WebContentsData::SetRecentlyAudible(contents, current_state);
-    WebContentsData::SetLastAudioChangeTime(contents, TimeTicks::Now());
+    data->SetRecentlyAudible(current_state);
+    data->SetLastAudioChangeTime(TimeTicks::Now());
   }
 }
 
+void TabManager::ActiveTabChanged(content::WebContents* old_contents,
+                                  content::WebContents* new_contents,
+                                  int index,
+                                  int reason) {
+  GetWebContentsData(new_contents)->SetDiscardState(false);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // TabManager, private:
 
 // static
 void TabManager::PurgeMemoryAndDiscardTab() {
   if (g_browser_process && g_browser_process->GetTabManager()) {
     TabManager* manager = g_browser_process->GetTabManager();
     manager->PurgeBrowserMemory();
     manager->DiscardTab();
   }
@@ skipping 112 matching lines @@
     for (int i = 0; i < model->count(); i++) {
       WebContents* contents = model->GetWebContentsAt(i);
       if (!contents->IsCrashed()) {
         TabStats stats;
         stats.is_app = is_browser_for_app;
         stats.is_internal_page =
             IsInternalPage(contents->GetLastCommittedURL());
         stats.is_playing_audio = IsAudioTab(contents);
         stats.is_pinned = model->IsTabPinned(i);
         stats.is_selected = browser_active && model->IsTabSelected(i);
-        stats.is_discarded = WebContentsData::IsDiscarded(contents);
+        stats.is_discarded = GetWebContentsData(contents)->IsDiscarded();
         stats.has_form_entry =
             contents->GetPageImportanceSignals().had_form_interaction;
-        stats.discard_count = WebContentsData::DiscardCount(contents);
+        stats.discard_count = GetWebContentsData(contents)->DiscardCount();
         stats.last_active = contents->GetLastActiveTime();
         stats.renderer_handle = contents->GetRenderProcessHost()->GetHandle();
         stats.child_process_host_id = contents->GetRenderProcessHost()->GetID();
 #if defined(OS_CHROMEOS)
         stats.oom_score = delegate_->GetOomScore(stats.child_process_host_id);
 #endif
         stats.title = contents->GetTitle();
         stats.tab_contents_id = IdFromWebContents(contents);
         stats_list->push_back(stats);
       }
@@ skipping 49 matching lines @@
   if (web_contents->GetPageImportanceSignals().had_form_interaction)
     return false;
 
   // Do not discard tabs that are playing audio as it's too distruptive to the
   // user experience. Note that tabs that have recently stopped playing audio by
   // at least |kAudioProtectionTimeSeconds| seconds are protected as well.
   if (IsAudioTab(web_contents))
     return false;
 
   // Do not discard a previously discarded tab if that's the desired behavior.
-  if (discard_once_ && WebContentsData::DiscardCount(web_contents) > 0)
+  if (discard_once_ && GetWebContentsData(web_contents)->DiscardCount() > 0)
     return false;
 
   return true;
 }
 
 WebContents* TabManager::DiscardWebContentsAt(int index, TabStripModel* model) {
   // Can't discard active index.
   if (model->active_index() == index)
     return nullptr;
 
   WebContents* old_contents = model->GetWebContentsAt(index);
 
   // Can't discard tabs that are already discarded.
-  if (WebContentsData::IsDiscarded(old_contents))
+  if (GetWebContentsData(old_contents)->IsDiscarded())
     return nullptr;
 
   // Record statistics before discarding to capture the memory state that leads
   // to the discard.
   RecordDiscardStatistics();
 
   WebContents* null_contents =
       WebContents::Create(WebContents::CreateParams(model->profile()));
   // Copy over the state from the navigation controller to preserve the
   // back/forward history and to continue to display the correct title/favicon.
   null_contents->GetController().CopyStateFrom(old_contents->GetController());
 
   // Make sure to persist the last active time property.
   null_contents->SetLastActiveTime(old_contents->GetLastActiveTime());
   // Copy over the discard count.
   WebContentsData::CopyState(old_contents, null_contents);
 
   // Replace the discarded tab with the null version.
   model->ReplaceWebContentsAt(index, null_contents);
   // Mark the tab so it will reload when clicked on.
-  WebContentsData::SetDiscardState(null_contents, true);
-  WebContentsData::IncrementDiscardCount(null_contents);
+  GetWebContentsData(null_contents)->SetDiscardState(true);
+  GetWebContentsData(null_contents)->IncrementDiscardCount();
 
   // Discard the old tab's renderer.
   // TODO(jamescook): This breaks script connections with other tabs.
   // Find a different approach that doesn't do that, perhaps based on navigation
   // to swappedout://.
   delete old_contents;
   recent_tab_discard_ = true;
 
   return null_contents;
 }
@@ skipping 10 matching lines @@
     LogMemoryAndDiscardTab();
   }
   // TODO(skuhne): If more memory pressure levels are introduced, consider
   // calling PurgeBrowserMemory() before CRITICAL is reached.
 }
 
 bool TabManager::IsAudioTab(WebContents* contents) const {
   if (contents->WasRecentlyAudible())
     return true;
   auto delta =
-      TimeTicks::Now() - WebContentsData::LastAudioChangeTime(contents);
+      TimeTicks::Now() - GetWebContentsData(contents)->LastAudioChangeTime();
   return delta < TimeDelta::FromSeconds(kAudioProtectionTimeSeconds);
 }
 
+TabManager::WebContentsData* TabManager::GetWebContentsData(
+    content::WebContents* contents) const {
+  WebContentsData::CreateForWebContents(contents);
+  return WebContentsData::FromWebContents(contents);
+}
+
 // static
 bool TabManager::CompareTabStats(TabStats first, TabStats second) {
   // Being currently selected is most important to protect.
   if (first.is_selected != second.is_selected)
     return first.is_selected;
 
   // Protect tabs with pending form entries.
   if (first.has_form_entry != second.has_form_entry)
     return first.has_form_entry;
 
@@ skipping 21 matching lines @@
   // sudden_termination_allowed false, and that covers too many common pages
   // with ad networks and statistics scripts.  Ideally check for beforeUnload
   // handlers, which are likely to present a dialog asking if the user wants to
   // discard state.  crbug.com/123049.
 
   // Being more recently active is more important.
   return first.last_active > second.last_active;
 }
 
 }  // namespace memory