Removes phantom tabs.

chrome/browser/tabs/tab_strip_model.h

 // 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.
 
 #ifndef CHROME_BROWSER_TABS_TAB_STRIP_MODEL_H_
 #define CHROME_BROWSER_TABS_TAB_STRIP_MODEL_H_
 
 #include <vector>
 
 #include "base/observer_list.h"
@@ skipping 79 matching lines @@
                         int to_index) {}
 
   // The specified TabContents at |index| changed in some way. |contents| may
   // be an entirely different object and the old value is no longer available
   // by the time this message is delivered.
   //
   // See TabChangeType for a description of |change_type|.
   virtual void TabChangedAt(TabContents* contents, int index,
                             TabChangeType change_type) {}
 
-  // The tab contents was replaced at the specified index. This is invoked when
-  // a tab becomes phantom. See description of phantom tabs in class description
-  // of TabStripModel for details.
-  virtual void TabReplacedAt(TabContents* old_contents,
-                             TabContents* new_contents, int index) {}
-
   // Invoked when the pinned state of a tab changes. This is not invoked if the
   // tab ends up moving as a result of the mini state changing.
   // See note in TabMiniStateChanged as to how this relates to
   // TabMiniStateChanged.
   virtual void TabPinnedStateChanged(TabContents* contents, int index) {}
 
   // Invoked if the mini state of a tab changes.  This is not invoked if the
   // tab ends up moving as a result of the mini state changing.
   // NOTE: this is sent when the pinned state of a non-app tab changes and is
   // sent in addition to TabPinnedStateChanged. UI code typically need not care
   // about TabPinnedStateChanged, but instead this.
   virtual void TabMiniStateChanged(TabContents* contents, int index) {}
 
   // Invoked when the blocked state of a tab changes.
   // NOTE: This is invoked when a tab becomes blocked/unblocked by a tab modal
   // window.
   virtual void TabBlockedStateChanged(TabContents* contents, int index) {}
 
-  // The TabStripModel now no longer has any phantom tabs. The implementer may
-  // use this as a trigger to try and close the window containing the
-  // TabStripModel, for example...
+  // The TabStripModel now no longer has any tabs. The implementer may use this
+  // as a trigger to try and close the window containing the TabStripModel, for
+  // example...
   virtual void TabStripEmpty() {}
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // TabStripModelDelegate
 //
 //  A delegate interface that the TabStripModel uses to perform work that it
 //  can't do itself, such as obtain a container HWND for creating new
 //  TabContents, creating new TabStripModels for detached tabs, etc.
@@ skipping 110 matching lines @@
 // . Mini-tab. Mini tabs are locked to the left side of the tab strip and
 //   rendered differently (small tabs with only a favicon). The model makes
 //   sure all mini-tabs are at the beginning of the tab strip. For example,
 //   if a non-mini tab is added it is forced to be with non-mini tabs. Requests
 //   to move tabs outside the range of the tab type are ignored. For example,
 //   a request to move a mini-tab after non-mini-tabs is ignored.
 //   You'll notice there is no explcit api for making a tab a mini-tab, rather
 //   there are two tab types that are implicitly mini-tabs:
 //   . App. Corresponds to an extension that wants an app tab. App tabs are
 //     identified by TabContents::is_app().
-//   . Pinned. Any tab can be pinned. A pinned tab is made phantom when closed.
-//     Non-app tabs whose pinned state is changed are moved to be with other
-//     mini-tabs or non-mini tabs.
-// . Phantom. Only pinned tabs may be made phantom. When a tab that can be made
-//   phantom is closed the renderer is shutdown, a new
-//   TabContents/NavigationController is created that has not yet loaded the
-//   renderer and observers are notified via the TabReplacedAt method. When a
-//   phantom tab is selected the renderer is loaded and the tab is no longer
-//   phantom.
-//   Phantom tabs do not prevent the tabstrip from closing, for example if the
-//   tabstrip has one phantom and one non-phantom tab and the non-phantom tab is
-//   closed, then the tabstrip/browser are closed.
+//   . Pinned. Any tab can be pinned. Non-app tabs whose pinned state is
+//     changed are moved to be with other mini-tabs or non-mini tabs.
 //
 //  A TabStripModel has one delegate that it relies on to perform certain tasks
 //  like creating new TabStripModels (probably hosted in Browser windows) when
 //  required. See TabStripDelegate above for more information.
 //
 //  A TabStripModel also has N observers (see TabStripModelObserver above),
 //  which can be registered via Add/RemoveObserver. An Observer is notified of
 //  tab creations, removals, moves, and other interesting events. The
 //  TabStrip implements this interface to know when to create new tabs in
 //  the View, and the Browser object likewise implements to be able to update
@@ skipping 35 matching lines @@
   TabStripModelDelegate* delegate() const { return delegate_; }
 
   // Add and remove observers to changes within this TabStripModel.
   void AddObserver(TabStripModelObserver* observer);
   void RemoveObserver(TabStripModelObserver* observer);
 
   // Retrieve the number of TabContentses/emptiness of the TabStripModel.
   int count() const { return static_cast<int>(contents_data_.size()); }
   bool empty() const { return contents_data_.empty(); }
 
-  // Returns true if there are any non-phantom tabs. When there are no
-  // non-phantom tabs the delegate is notified by way of TabStripEmpty and the
-  // browser closes.
-  bool HasNonPhantomTabs() const;
-
   // Retrieve the Profile associated with this TabStripModel.
   Profile* profile() const { return profile_; }
 
   // Retrieve the index of the currently selected TabContents.
   int selected_index() const { return selected_index_; }
 
   // Returns true if the tabstrip is currently closing all open tabs (via a
   // call to CloseAllTabs). As tabs close, the selection in the tabstrip
   // changes which notifies observers, which can use this as an optimization to
   // avoid doing meaningless or unhelpful work.
@@ skipping 114 matching lines @@
   bool TabsAreLoading() const;
 
   // Returns the controller controller that opened the TabContents at |index|.
   NavigationController* GetOpenerOfTabContentsAt(int index);
 
   // Returns the index of the next TabContents in the sequence of TabContentses
   // spawned by the specified NavigationController after |start_index|.
   // If |use_group| is true, the group property of the tab is used instead of
   // the opener to find the next tab. Under some circumstances the group
   // relationship may exist but the opener may not.
-  // NOTE: this skips phantom tabs.
   int GetIndexOfNextTabContentsOpenedBy(const NavigationController* opener,
                                         int start_index,
                                         bool use_group) const;
 
   // Returns the index of the first TabContents in the model opened by the
   // specified opener.
-  // NOTE: this skips phantom tabs.
   int GetIndexOfFirstTabContentsOpenedBy(const NavigationController* opener,
                                          int start_index) const;
 
   // Returns the index of the last TabContents in the model opened by the
   // specified opener, starting at |start_index|.
-  // NOTE: this skips phantom tabs.
   int GetIndexOfLastTabContentsOpenedBy(const NavigationController* opener,
                                         int start_index) const;
 
   // Called by the Browser when a navigation is about to occur in the specified
   // TabContents. Depending on the tab, and the transition type of the
   // navigation, the TabStripModel may adjust its selection and grouping
   // behavior.
   void TabNavigating(TabContents* contents, PageTransition::Type transition);
 
   // Forget all Opener relationships that are stored (but _not_ group
@@ skipping 29 matching lines @@
   // See description above class for details on this.
   bool IsMiniTab(int index) const;
 
   // Is the tab at |index| an app?
   // See description above class for details on app tabs.
   bool IsAppTab(int index) const;
 
   // Returns true if the toolbar is visible for the tab at |index|.
   bool IsToolbarVisible(int index) const;
 
-  // Returns true if the tab is a phantom tab. A phantom tab is one where the
-  // renderer has not been loaded.
-  // See description above class for details on phantom tabs.
-  bool IsPhantomTab(int index) const;
-
   // Returns true if the tab at |index| is blocked by a tab modal dialog.
   bool IsTabBlocked(int index) const;
 
   // Returns the index of the first tab that is not a mini-tab. This returns
   // |count()| if all of the tabs are mini-tabs, and 0 if none of the tabs are
   // mini-tabs.
   int IndexOfFirstNonMiniTab() const;
 
   // Returns a valid index for inserting a new tab into this model. |index| is
   // the proposed index and |mini_tab| is true if inserting a tab will become
@@ skipping 125 matching lines @@
   int GetNewTabCount() const;
 
   // Convenience for setting the opener pointer for the specified |contents| to
   // be |opener|'s NavigationController.
   void SetOpenerForContents(TabContents* contents, TabContents* opener);
 
   // Selects either the next tab (|foward| is true), or the previous tab
   // (|forward| is false).
   void SelectRelativeTab(bool forward);
 
-  // Returns the first non-phantom tab starting at |index|, skipping the tab at
-  // |ignore_index|.
-  int IndexOfNextNonPhantomTab(int index, int ignore_index);
-
-  // Returns true if the tab at the specified index should be made phantom when
-  // the tab is closing.
-  bool ShouldMakePhantomOnClose(int index);
-
-  // Makes the tab a phantom tab.
-  void MakePhantom(int index);
+  // Returns the first tab starting at |index|.
+  int IndexOfNextTab(int index);
 
   // Does the work of MoveTabContentsAt. This has no checks to make sure the
   // position is valid, those are done in MoveTabContentsAt.
   void MoveTabContentsAtImpl(int index,
                              int to_position,
                              bool select_after_move);
 
   // Returns true if the tab represented by the specified data has an opener
   // that matches the specified one. If |use_group| is true, then this will
   // fall back to check the group relationship as well.
@@ skipping 84 matching lines @@
   typedef ObserverList<TabStripModelObserver> TabStripModelObservers;
   TabStripModelObservers observers_;
 
   // A scoped container for notification registries.
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStripModel);
 };
 
 #endif  // CHROME_BROWSER_TABS_TAB_STRIP_MODEL_H_