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

chrome/browser/ui/tabs/tab_strip_model.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/ui/tabs/tab_strip_model.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
+#include "chrome/browser/ui/tabs/tab_discard_state.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/web_contents_sizer.h"
 #include "chrome/common/url_constants.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
@@ skipping 10 matching lines @@
   UMA_TAB_DISCARDING_DISCARD_TAB_AUDIO,
   UMA_TAB_DISCARDING_TAB_DISCARDING_MAX
 };
 
 // Records an UMA tab discarding event.
 void RecordUMATabDiscarding(UMATabDiscarding event) {
   UMA_HISTOGRAM_ENUMERATION("Tab.Discarding", event,
                             UMA_TAB_DISCARDING_TAB_DISCARDING_MAX);
 }
 
+// Records the number of discards that a tab has been through.
+void RecordUMADiscardCount(int discard_count) {
+  UMA_HISTOGRAM_COUNTS("Tab.Discarding.DiscardCount", discard_count);
+}
+
 // Returns true if the specified transition is one of the types that cause the
 // opener relationships for the tab in which the transition occurred to be
 // forgotten. This is generally any navigation that isn't a link click (i.e.
 // any navigation that can be considered to be the start of a new task distinct
 // from what had previously occurred in that tab).
 bool ShouldForgetOpenersForTransition(ui::PageTransition transition) {
   return transition == ui::PAGE_TRANSITION_TYPED ||
       transition == ui::PAGE_TRANSITION_AUTO_BOOKMARK ||
       transition == ui::PAGE_TRANSITION_GENERATED ||
       transition == ui::PAGE_TRANSITION_KEYWORD ||
@@ skipping 101 matching lines @@
   WebContents* opener() const { return opener_; }
   void set_opener(WebContents* value) { opener_ = value; }
 
   // Alters the properties of the WebContents.
   bool reset_group_on_select() const { return reset_group_on_select_; }
   void set_reset_group_on_select(bool value) { reset_group_on_select_ = value; }
   bool pinned() const { return pinned_; }
   void set_pinned(bool value) { pinned_ = value; }
   bool blocked() const { return blocked_; }
   void set_blocked(bool value) { blocked_ = value; }
-  bool discarded() const { return discarded_; }
-  void set_discarded(bool value) { discarded_ = value; }
 
  private:
   // Make sure that if someone deletes this WebContents out from under us, it
   // is properly removed from the tab strip.
   void WebContentsDestroyed() override;
 
   // Marks the tab as no longer discarded if it has been reloaded from another
   // source (ie: context menu).
   void DidStartLoading() override;
 
@@ skipping 27 matching lines @@
   // selection shifts to _any_ tab (including their opener), the group
   // relationship is reset to avoid confusing close sequencing.
   bool reset_group_on_select_;
 
   // Is the tab pinned?
   bool pinned_;
 
   // Is the tab interaction blocked by a modal dialog?
   bool blocked_;
 
-  // Has the tab data been discarded to save memory?
-  bool discarded_;
-
   DISALLOW_COPY_AND_ASSIGN(WebContentsData);
 };
 
 TabStripModel::WebContentsData::WebContentsData(TabStripModel* tab_strip_model,
                                                 WebContents* contents)
     : content::WebContentsObserver(contents),
       contents_(contents),
       tab_strip_model_(tab_strip_model),
       group_(NULL),
       opener_(NULL),
       reset_group_on_select_(false),
       pinned_(false),
-      blocked_(false),
-      discarded_(false) {
-}
+      blocked_(false) {}
 
 void TabStripModel::WebContentsData::SetWebContents(WebContents* contents) {
   contents_ = contents;
   Observe(contents);
 }
 
 void TabStripModel::WebContentsData::WebContentsDestroyed() {
   DCHECK_EQ(contents_, web_contents());
 
   // Note that we only detach the contents here, not close it - it's
   // already been closed. We just want to undo our bookkeeping.
   int index = tab_strip_model_->GetIndexOfWebContents(web_contents());
   DCHECK_NE(TabStripModel::kNoTab, index);
   tab_strip_model_->DetachWebContentsAt(index);
 }
 
 void TabStripModel::WebContentsData::DidStartLoading() {
-  set_discarded(false);
+  TabDiscardState::SetDiscardState(contents_, false);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, public:
 
 TabStripModel::TabStripModel(TabStripModelDelegate* delegate, Profile* profile)
     : delegate_(delegate),
       profile_(profile),
       closing_all_(false),
       in_notify_(false),
@@ skipping 127 matching lines @@
   WebContents* null_contents =
       WebContents::Create(WebContents::CreateParams(profile()));
   WebContents* old_contents = GetWebContentsAtImpl(index);
   bool is_playing_audio = old_contents->WasRecentlyAudible();
   // Copy over the state from the navigation controller so we preserve the
   // back/forward history and continue to display the correct title/favicon.
   null_contents->GetController().CopyStateFrom(old_contents->GetController());
 
   // Make sure we persist the last active time property.
   null_contents->SetLastActiveTime(old_contents->GetLastActiveTime());
+  // Copy over the discard count.
+  TabDiscardState::CopyState(old_contents, null_contents);
 
   // Replace the tab we're discarding with the null version.
   ReplaceWebContentsAt(index, null_contents);
   // Mark the tab so it will reload when we click.
-  if (!contents_data_[index]->discarded()) {
-    contents_data_[index]->set_discarded(true);
+  if (!TabDiscardState::IsDiscarded(null_contents)) {
+    TabDiscardState::SetDiscardState(null_contents, true);
+    TabDiscardState::IncrementDiscardCount(null_contents);
     RecordUMATabDiscarding(UMA_TAB_DISCARDING_DISCARD_TAB);
+    RecordUMADiscardCount(TabDiscardState::DiscardCount(null_contents));
     if (is_playing_audio)
       RecordUMATabDiscarding(UMA_TAB_DISCARDING_DISCARD_TAB_AUDIO);
   }
   // Discard the old tab's renderer.
   // TODO(jamescook): This breaks script connections with other tabs.
   // We need to find a different approach that doesn't do that, perhaps based
   // on navigation to swappedout://.
   delete old_contents;
   return null_contents;
 }
@@ skipping 304 matching lines @@
 
 bool TabStripModel::IsTabPinned(int index) const {
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->pinned();
 }
 
 bool TabStripModel::IsTabBlocked(int index) const {
   return contents_data_[index]->blocked();
 }
 
-bool TabStripModel::IsTabDiscarded(int index) const {
-  return contents_data_[index]->discarded();
-}
-
 int TabStripModel::IndexOfFirstNonPinnedTab() const {
   for (size_t i = 0; i < contents_data_.size(); ++i) {
     if (!IsTabPinned(static_cast<int>(i)))
       return static_cast<int>(i);
   }
   // No pinned tabs.
   return count();
 }
 
 int TabStripModel::ConstrainInsertionIndex(int index, bool pinned_tab) {
@@ skipping 571 matching lines @@
                  ? TabStripModelObserver::CHANGE_REASON_USER_GESTURE
                  : TabStripModelObserver::CHANGE_REASON_NONE;
     CHECK(!in_notify_);
     in_notify_ = true;
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
         ActiveTabChanged(old_contents,
                          new_contents,
                          active_index(),
                          reason));
     in_notify_ = false;
-    // Activating a discarded tab reloads it, so it is no longer discarded.
-    if (contents_data_[active_index()]->discarded()) {
-      contents_data_[active_index()]->set_discarded(false);
-      RecordUMATabDiscarding(UMA_TAB_DISCARDING_SWITCH_TO_DISCARDED_TAB);
-    } else {
-      RecordUMATabDiscarding(UMA_TAB_DISCARDING_SWITCH_TO_LOADED_TAB);
-    }
   }
 }
 
 void TabStripModel::NotifyIfActiveOrSelectionChanged(
     WebContents* old_contents,
     NotifyTypes notify_types,
     const ui::ListSelectionModel& old_model) {
   NotifyIfActiveTabChanged(old_contents, notify_types);
 
   if (!selection_model().Equals(old_model)) {
@@ skipping 90 matching lines @@
 
 void TabStripModel::FixOpenersAndGroupsReferencing(int index) {
   WebContents* old_contents = GetWebContentsAtImpl(index);
   for (WebContentsData* data : contents_data_) {
     if (data->group() == old_contents)
       data->set_group(contents_data_[index]->group());
     if (data->opener() == old_contents)
       data->set_opener(contents_data_[index]->opener());
   }
 }