Improve the about/discards UI, allowing each tab to be individually closed.

chrome/browser/memory/oom_priority_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/oom_priority_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 100 matching lines @@
     }
   }
 }
 
 void OomPriorityManager::Stop() {
   update_timer_.Stop();
   recent_tab_discard_timer_.Stop();
   memory_pressure_listener_.reset();
 }
 
-std::vector<base::string16> OomPriorityManager::GetTabTitles() {
-  TabStatsList stats = GetTabStatsOnUIThread();
-  std::vector<base::string16> titles;
-  titles.reserve(stats.size());
-  TabStatsList::iterator it = stats.begin();
-  for (; it != stats.end(); ++it) {
-    base::string16 str;
-    str.reserve(4096);
-#if defined(OS_CHROMEOS)
-    int score = delegate_->GetOomScore(it->child_process_host_id);
-    str += base::IntToString16(score);
-    str += base::ASCIIToUTF16(" - ");
-#endif
-    str += it->title;
-    str += base::ASCIIToUTF16(it->is_app ? " app" : "");
-    str += base::ASCIIToUTF16(it->is_internal_page ? " internal_page" : "");
-    str += base::ASCIIToUTF16(it->is_playing_audio ? " playing_audio" : "");
-    str += base::ASCIIToUTF16(it->is_pinned ? " pinned" : "");
-    str += base::ASCIIToUTF16(it->is_discarded ? " discarded" : "");
-    titles.push_back(str);
+// Things we need to collect on the browser thread (because TabStripModel isn't
+// thread safe):
+// 1) whether or not a tab is pinned
+// 2) last time a tab was selected
+// 3) is the tab currently selected
+TabStatsList OomPriorityManager::GetTabStats() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  TabStatsList stats_list;
+  stats_list.reserve(32);  // 99% of users have < 30 tabs open
+
+  // We go through each window to get all the tabs. Depending on the platform,
+  // windows are either native or ash or both. We want to make sure to go
+  // through them all, starting with the active window first (we use
+  // chrome::GetActiveDesktop to get the current used type).
+  AddTabStats(BrowserList::GetInstance(chrome::GetActiveDesktop()), true,
+              &stats_list);
+  if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_NATIVE) {
+    AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_NATIVE),
+                false, &stats_list);
+  } else if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_ASH) {
+    AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH), false,
+                &stats_list);
   }
-  return titles;
+
+  // Sort the data we collected 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;
 }
 
 // TODO(jamescook): This should consider tabs with references to other tabs,
 // such as tabs created with JavaScript window.open().  We might want to
 // discard the entire set together, or use that in the priority computation.
 bool OomPriorityManager::DiscardTab() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  TabStatsList stats = GetTabStatsOnUIThread();
+  TabStatsList stats = GetTabStats();
   if (stats.empty())
     return false;
   // Loop until we find a non-discarded tab to kill.
   for (TabStatsList::const_reverse_iterator stats_rit = stats.rbegin();
        stats_rit != stats.rend(); ++stats_rit) {
     int64 least_important_tab_id = stats_rit->tab_contents_id;
     if (DiscardTabById(least_important_tab_id))
       return true;
   }
   return false;
 }
 
+bool OomPriorityManager::DiscardTabById(int64 target_web_contents_id) {
+  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
+    Browser* browser = *it;
+    TabStripModel* model = browser->tab_strip_model();
+    for (int idx = 0; idx < model->count(); idx++) {
+      // Can't discard tabs that are already discarded or active.
+      if (model->IsTabDiscarded(idx) || (model->active_index() == idx))
+        continue;
+      WebContents* web_contents = model->GetWebContentsAt(idx);
+      int64 web_contents_id = IdFromWebContents(web_contents);
+      if (web_contents_id == target_web_contents_id) {
+        VLOG(1) << "Discarding tab " << idx << " id " << target_web_contents_id;
+        // Record statistics before discarding because we want to capture the
+        // memory state that lead to the discard.
+        RecordDiscardStatistics();
+        model->DiscardWebContentsAt(idx);
+        recent_tab_discard_ = true;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 void OomPriorityManager::LogMemoryAndDiscardTab() {
   LogMemory("Tab Discards Memory details",
             base::Bind(&OomPriorityManager::PurgeMemoryAndDiscardTab));
 }
 
 void OomPriorityManager::LogMemory(const std::string& title,
                                    const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OomMemoryDetails::Log(title, callback);
 }
@@ skipping 23 matching lines @@
   // Prefix-match against the table above. Use strncmp to avoid allocating
   // memory to convert the URL prefix constants into std::strings.
   for (size_t i = 0; i < arraysize(kInternalPagePrefixes); ++i) {
     if (!strncmp(url.spec().c_str(), kInternalPagePrefixes[i],
                  strlen(kInternalPagePrefixes[i])))
       return true;
   }
   return false;
 }
 
-bool OomPriorityManager::DiscardTabById(int64 target_web_contents_id) {
-  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
-    Browser* browser = *it;
-    TabStripModel* model = browser->tab_strip_model();
-    for (int idx = 0; idx < model->count(); idx++) {
-      // Can't discard tabs that are already discarded or active.
-      if (model->IsTabDiscarded(idx) || (model->active_index() == idx))
-        continue;
-      WebContents* web_contents = model->GetWebContentsAt(idx);
-      int64 web_contents_id = IdFromWebContents(web_contents);
-      if (web_contents_id == target_web_contents_id) {
-        LOG(WARNING) << "Discarding tab " << idx << " id "
-                     << target_web_contents_id;
-        // Record statistics before discarding because we want to capture the
-        // memory state that lead to the discard.
-        RecordDiscardStatistics();
-        model->DiscardWebContentsAt(idx);
-        recent_tab_discard_ = true;
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
 void OomPriorityManager::RecordDiscardStatistics() {
   // Record a raw count so we can compare to discard reloads.
   discard_count_++;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.Discard.DiscardCount", discard_count_, 1,
                               1000, 50);
 
   // TODO(jamescook): Maybe incorporate extension count?
   UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.Discard.TabCount", GetTabCount(), 1, 100,
                               50);
 #if defined(OS_CHROMEOS)
@@ skipping 114 matching lines @@
       // We were probably suspended, move our event timers forward in time so
       // when we subtract them out later we are counting "uptime".
       start_time_ += suspend_time;
       if (!last_discard_time_.is_null())
         last_discard_time_ += suspend_time;
     }
   }
   last_adjust_time_ = TimeTicks::Now();
 
 #if defined(OS_CHROMEOS)
-  TabStatsList stats_list = GetTabStatsOnUIThread();
+  TabStatsList stats_list = GetTabStats();
   // This starts the CrOS specific OOM adjustments in /proc/<pid>/oom_score_adj.
   delegate_->AdjustOomPriorities(stats_list);
 #endif
 }
 
-// Things we need to collect on the browser thread (because TabStripModel isn't
-// thread safe):
-// 1) whether or not a tab is pinned
-// 2) last time a tab was selected
-// 3) is the tab currently selected
-TabStatsList OomPriorityManager::GetTabStatsOnUIThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  TabStatsList stats_list;
-  stats_list.reserve(32);  // 99% of users have < 30 tabs open
-
-  // We go through each window to get all the tabs. Depending on the platform,
-  // windows are either native or ash or both. We want to make sure to go
-  // through them all, starting with the active window first (we use
-  // chrome::GetActiveDesktop to get the current used type).
-  AddTabStats(BrowserList::GetInstance(chrome::GetActiveDesktop()), true,
-              &stats_list);
-  if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_NATIVE) {
-    AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_NATIVE),
-                false, &stats_list);
-  } else if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_ASH) {
-    AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH), false,
-                &stats_list);
-  }
-
-  // Sort the data we collected 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;
-}
-
 void OomPriorityManager::AddTabStats(BrowserList* browser_list,
                                      bool active_desktop,
                                      TabStatsList* stats_list) {
   // If it's the active desktop, the first window will be the active one.
   // Otherwise, we assume no active windows.
   bool browser_active = active_desktop;
   for (BrowserList::const_reverse_iterator browser_iterator =
            browser_list->begin_last_active();
        browser_iterator != browser_list->end_last_active();
        ++browser_iterator) {
     Browser* browser = *browser_iterator;
     bool is_browser_for_app = browser->is_app();
     const TabStripModel* model = browser->tab_strip_model();
     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 = chrome::IsPlayingAudio(contents);
         stats.is_pinned = model->IsTabPinned(i);
         stats.is_selected = browser_active && model->IsTabSelected(i);
         stats.is_discarded = model->IsTabDiscarded(i);
         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);
       }
     }
     // We process the active browser window in the first iteration.
     browser_active = false;
   }
 }
 
 void OomPriorityManager::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   // For the moment we only do something when we reach a critical state.
   if (memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     LogMemoryAndDiscardTab();
   }
   // TODO(skuhne): If more memory pressure levels are introduced, we might
   // consider to call PurgeBrowserMemory() before CRITICAL is reached.
 }
 
 }  // namespace memory