Removes phantom tabs.

chrome/browser/tabs/tab_strip_model.cc

 // Copyright (c) 2010 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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/stl_util-inl.h"
@@ skipping 62 matching lines @@
 }
 
 void TabStripModel::AddObserver(TabStripModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void TabStripModel::RemoveObserver(TabStripModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-bool TabStripModel::HasNonPhantomTabs() const {
-  for (int i = 0; i < count(); i++) {
-    if (!IsPhantomTab(i))
-      return true;
-  }
-  return false;
-}
-
 void TabStripModel::SetInsertionPolicy(InsertionPolicy policy) {
   order_controller_->set_insertion_policy(policy);
 }
 
 TabStripModel::InsertionPolicy TabStripModel::insertion_policy() const {
   return order_controller_->insertion_policy();
 }
 
 bool TabStripModel::HasObserver(TabStripModelObserver* observer) {
   return observers_.HasObserver(observer);
@@ skipping 65 matching lines @@
   InternalCloseTabs(closing_tabs, CLOSE_NONE);
 }
 
 TabContents* TabStripModel::DetachTabContentsAt(int index) {
   if (contents_data_.empty())
     return NULL;
 
   DCHECK(ContainsIndex(index));
   TabContents* removed_contents = GetContentsAt(index);
   int next_selected_index =
-      order_controller_->DetermineNewSelectedIndex(index, true);
+      order_controller_->DetermineNewSelectedIndex(index);
   delete contents_data_.at(index);
   contents_data_.erase(contents_data_.begin() + index);
-  next_selected_index = IndexOfNextNonPhantomTab(next_selected_index, -1);
-  if (!HasNonPhantomTabs())
+  next_selected_index = IndexOfNextTab(next_selected_index);
+  if (empty())
     closing_all_ = true;
   TabStripModelObservers::Iterator iter(observers_);
   while (TabStripModelObserver* obs = iter.GetNext()) {
     obs->TabDetachedAt(removed_contents, index);
-    if (!HasNonPhantomTabs())
+    if (empty())
       obs->TabStripEmpty();
   }
-  if (HasNonPhantomTabs()) {
+  if (!empty()) {
     if (index == selected_index_) {
       ChangeSelectedContentsFrom(removed_contents, next_selected_index, false);
     } else if (index < selected_index_) {
       // The selected tab didn't change, but its position shifted; update our
       // index to continue to point at it.
       --selected_index_;
     }
   }
   return removed_contents;
 }
@@ skipping 90 matching lines @@
   return contents_data_.at(index)->opener;
 }
 
 int TabStripModel::GetIndexOfNextTabContentsOpenedBy(
     const NavigationController* opener, int start_index, bool use_group) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   // Check tabs after start_index first.
   for (int i = start_index + 1; i < count(); ++i) {
-    if (OpenerMatches(contents_data_[i], opener, use_group) &&
-        !IsPhantomTab(i)) {
+    if (OpenerMatches(contents_data_[i], opener, use_group))
       return i;
-    }
   }
   // Then check tabs before start_index, iterating backwards.
   for (int i = start_index - 1; i >= 0; --i) {
-    if (OpenerMatches(contents_data_[i], opener, use_group) &&
-        !IsPhantomTab(i)) {
+    if (OpenerMatches(contents_data_[i], opener, use_group))
       return i;
-    }
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfFirstTabContentsOpenedBy(
     const NavigationController* opener,
     int start_index) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   for (int i = 0; i < start_index; ++i) {
-    if (contents_data_[i]->opener == opener && !IsPhantomTab(i))
+    if (contents_data_[i]->opener == opener)
       return i;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfLastTabContentsOpenedBy(
     const NavigationController* opener, int start_index) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   TabContentsDataVector::const_iterator end =
       contents_data_.begin() + start_index;
   TabContentsDataVector::const_iterator iter = contents_data_.end();
   TabContentsDataVector::const_iterator next;
   for (; iter != end; --iter) {
     next = iter - 1;
     if (next == end)
       break;
-    if ((*next)->opener == opener &&
-        !IsPhantomTab(static_cast<int>(next - contents_data_.begin()))) {
+    if ((*next)->opener == opener)
       return static_cast<int>(next - contents_data_.begin());
-    }
   }
   return kNoTab;
 }
 
 void TabStripModel::TabNavigating(TabContents* contents,
                                   PageTransition::Type transition) {
   if (ShouldForgetOpenersForTransition(transition)) {
     // Don't forget the openers if this tab is a New Tab page opened at the
     // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one
     // navigation of one of these transition types before resetting the
@@ skipping 93 matching lines @@
 bool TabStripModel::IsToolbarVisible(int index) const {
   Extension* extension_app = GetTabContentsAt(index)->extension_app();
   if (!extension_app)
     return true;
 
   ExtensionsService* service = profile()->GetExtensionsService();
   ExtensionPrefs* prefs = service->extension_prefs();
   return prefs->AreAppTabToolbarsVisible(extension_app->id());
 }
 
-bool TabStripModel::IsPhantomTab(int index) const {
-  return IsTabPinned(index) &&
-         GetTabContentsAt(index)->controller().needs_reload();
-}
-
 bool TabStripModel::IsTabBlocked(int index) const {
   return contents_data_[index]->blocked;
 }
 
 int TabStripModel::IndexOfFirstNonMiniTab() const {
   for (size_t i = 0; i < contents_data_.size(); ++i) {
     if (!contents_data_[i]->contents->is_app() && !contents_data_[i]->pinned)
       return static_cast<int>(i);
   }
   // No mini-tabs.
@@ skipping 215 matching lines @@
       UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_RestoreTab"),
                                 profile_);
       delegate_->RestoreTab();
       break;
     }
     case CommandTogglePinned: {
       UserMetrics::RecordAction(
           UserMetricsAction("TabContextMenu_TogglePinned"),
           profile_);
 
-      if (IsPhantomTab(context_index)) {
-        // The tab is a phantom tab, close it.
-        CloseTabContentsAt(context_index,
-                           CLOSE_USER_GESTURE | CLOSE_CREATE_HISTORICAL_TAB);
-      } else {
-        SelectTabContentsAt(context_index, true);
-        SetTabPinned(context_index, !IsTabPinned(context_index));
-      }
+      SelectTabContentsAt(context_index, true);
+      SetTabPinned(context_index, !IsTabPinned(context_index));
       break;
     }
     case CommandToggleToolbar: {
       UserMetrics::RecordAction(
           UserMetricsAction("TabContextMenu_ToggleToolbar"),
           profile_);
 
       SelectTabContentsAt(context_index, true);
 
       Extension* extension_app =
@@ skipping 75 matching lines @@
                             const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::TAB_CONTENTS_DESTROYED: {
       // Sometimes, on qemu, it seems like a TabContents object can be destroyed
       // while we still have a reference to it. We need to break this reference
       // here so we don't crash later.
       int index = GetIndexOfTabContents(Source<TabContents>(source).ptr());
       if (index != TabStripModel::kNoTab) {
         // Note that we only detach the contents here, not close it - it's
         // already been closed. We just want to undo our bookkeeping.
-        if (ShouldMakePhantomOnClose(index)) {
-          // We don't actually allow pinned tabs to close. Instead they become
-          // phantom.
-          MakePhantom(index);
-        } else {
-          DetachTabContentsAt(index);
-        }
+        DetachTabContentsAt(index);
       }
       break;
     }
 
     case NotificationType::EXTENSION_UNLOADED: {
       Extension* extension = Details<Extension>(details).ptr();
       // Iterate backwards as we may remove items while iterating.
       for (int i = count() - 1; i >= 0; i--) {
         TabContents* contents = GetTabContentsAt(i);
         if (contents->extension_app() == extension) {
@@ skipping 147 matching lines @@
   int index = GetIndexOfTabContents(contents);
   contents_data_.at(index)->opener = &opener->controller();
 }
 
 void TabStripModel::SelectRelativeTab(bool next) {
   // This may happen during automated testing or if a user somehow buffers
   // many key accelerators.
   if (contents_data_.empty())
     return;
 
-  // Skip pinned-app-phantom tabs when iterating.
-  int index = selected_index_;
   int delta = next ? 1 : -1;
-  do {
-    index = (index + count() + delta) % count();
-  } while (index != selected_index_ && IsPhantomTab(index));
+  int index = (selected_index_ + count() + delta) % count();
   SelectTabContentsAt(index, true);
 }
 
-int TabStripModel::IndexOfNextNonPhantomTab(int index,
-                                            int ignore_index) {
-  if (index == kNoTab)
-    return kNoTab;
-
-  if (empty())
-    return index;
-
-  index = std::min(count() - 1, std::max(0, index));
-  int start = index;
-  do {
-    if (index != ignore_index && !IsPhantomTab(index))
-      return index;
-    index = (index + 1) % count();
-  } while (index != start);
-
-  // All phantom tabs.
-  return start;
+int TabStripModel::IndexOfNextTab(int index) {
+  return (index == kNoTab || empty()) ?
+      index : std::min(count() - 1, std::max(0, index));
 }
 
-bool TabStripModel::ShouldMakePhantomOnClose(int index) {
-  if (IsTabPinned(index) && !IsPhantomTab(index) && !closing_all_ &&
-      profile()) {
-    if (!IsAppTab(index))
-      return true;  // Always make non-app tabs go phantom.
-
-    ExtensionsService* extension_service = profile()->GetExtensionsService();
-    if (!extension_service)
-      return false;
-
-    Extension* extension_app = GetTabContentsAt(index)->extension_app();
-    DCHECK(extension_app);
-
-    // Only allow the tab to be made phantom if the extension still exists.
-    return extension_service->GetExtensionById(extension_app->id(),
-                                               false) != NULL;
-  }
-  return false;
-}
-
-void TabStripModel::MakePhantom(int index) {
-  TabContents* old_contents = GetContentsAt(index);
-  TabContents* new_contents = old_contents->CloneAndMakePhantom();
-
-  contents_data_[index]->contents = new_contents;
-
-  // And notify observers.
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabReplacedAt(old_contents, new_contents, index));
-
-  if (selected_index_ == index && HasNonPhantomTabs()) {
-    // Change the selection, otherwise we're going to force the phantom tab
-    // to become selected.
-    // NOTE: we must do this after the call to Replace otherwise browser's
-    // TabSelectedAt will send out updates for the old TabContents which we've
-    // already told observers has been closed (we sent out TabClosing at).
-    int new_selected_index =
-        order_controller_->DetermineNewSelectedIndex(index, false);
-    new_selected_index = IndexOfNextNonPhantomTab(new_selected_index,
-                                                  index);
-    SelectTabContentsAt(new_selected_index, true);
-  }
-
-  if (!HasNonPhantomTabs())
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_, TabStripEmpty());
-}
-
-
 void TabStripModel::MoveTabContentsAtImpl(int index, int to_position,
                                           bool select_after_move) {
   TabContentsData* moved_data = contents_data_.at(index);
   contents_data_.erase(contents_data_.begin() + index);
   contents_data_.insert(contents_data_.begin() + to_position, moved_data);
 
   // if !select_after_move, keep the same tab selected as was selected before.
   if (select_after_move || index == selected_index_) {
     selected_index_ = to_position;
   } else if (index < selected_index_ && to_position >= selected_index_) {
     selected_index_--;
   } else if (index > selected_index_ && to_position <= selected_index_) {
     selected_index_++;
   }
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabMoved(moved_data->contents, index, to_position));
 }
 
 // static
 bool TabStripModel::OpenerMatches(const TabContentsData* data,
                                   const NavigationController* opener,
                                   bool use_group) {
   return data->opener == opener || (use_group && data->group == opener);
 }