Add option to disallow the discarding of a tab that was previously discarded.

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 14 matching lines @@
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/memory/oom_memory_details.h"
 #include "chrome/browser/memory/system_memory_stats_recorder.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
+#include "chrome/browser/ui/tabs/tab_discard_state.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/memory/oom_priority_manager_delegate_chromeos.h"
@@ skipping 43 matching lines @@
 
   return -1;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // OomPriorityManager
 
 OomPriorityManager::OomPriorityManager()
-    : discard_count_(0), recent_tab_discard_(false) {
+    : discard_count_(0), recent_tab_discard_(false), discard_once_(false) {
 #if defined(OS_CHROMEOS)
   delegate_.reset(new OomPriorityManagerDelegate);
 #endif
 }
 
 OomPriorityManager::~OomPriorityManager() {
   Stop();
 }
 
-void OomPriorityManager::Start() {
+void OomPriorityManager::Start(bool discard_once) {
+  discard_once_ = discard_once;
   if (!update_timer_.IsRunning()) {
     update_timer_.Start(FROM_HERE,
                         TimeDelta::FromSeconds(kAdjustmentIntervalSeconds),
                         this, &OomPriorityManager::UpdateTimerCallback);
   }
   if (!recent_tab_discard_timer_.IsRunning()) {
     recent_tab_discard_timer_.Start(
         FROM_HERE, TimeDelta::FromSeconds(kRecentTabDiscardIntervalSeconds),
         this, &OomPriorityManager::RecordRecentTabDiscard);
   }
@@ skipping 52 matching lines @@
 // discard the entire set together, or use that in the priority computation.
 bool OomPriorityManager::DiscardTab() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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))
+    if (CanDiscardTab(least_important_tab_id) &&
+        DiscardTabById(least_important_tab_id))
       return true;
   }
   return false;
 }
 
 bool OomPriorityManager::DiscardTabById(int64 target_web_contents_id) {
   TabStripModel* model;
   int idx = FindTabStripModelById(target_web_contents_id, &model);
 
   if (idx == -1)
     return false;
 
-  // Can't discard tabs that are already discarded or active.
-  if (model->IsTabDiscarded(idx) || (model->active_index() == idx))
+  // Can't discard active tabs
+  if (model->active_index() == idx)
     return false;
 
-  // We also ignore tabs that are playing audio as it's too distruptive to
-  // the user experience.
-  if (model->GetWebContentsAt(idx)->WasRecentlyAudible())
+  WebContents* web_contents = model->GetWebContentsAt(idx);
+  // Can't discard tabs that are already discarded.
+  if (TabDiscardState::IsDiscarded(web_contents))
     return false;
 
   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;
@@ skipping 207 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 = contents->WasRecentlyAudible();
         stats.is_pinned = model->IsTabPinned(i);
         stats.is_selected = browser_active && model->IsTabSelected(i);
-        stats.is_discarded = model->IsTabDiscarded(i);
+        stats.is_discarded = TabDiscardState::IsDiscarded(contents);
+        stats.discard_count = TabDiscardState::DiscardCount(contents);
         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 11 matching lines @@
 
   // 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.
 }
 
+bool OomPriorityManager::CanDiscardTab(int64 target_web_contents_id) const {
+  TabStripModel* model;
+  int idx = FindTabStripModelById(target_web_contents_id, &model);
+
+  if (idx == -1)
+    return false;
+
+  WebContents* web_contents = model->GetWebContentsAt(idx);
+  // We do not discard tabs that are playing audio as it's too distruptive to
+  // the user experience.
+  if (web_contents->WasRecentlyAudible())
+    return false;
+
+  // We also make sure not to discard a previously discarded tab if that's the
+  // desired behavior.
+  if (discard_once_ && TabDiscardState::DiscardCount(web_contents) > 0)
+    return false;
+
+  return true;
+}
+
 }  // namespace memory