Home | History | Annotate | Download | only in tabs
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_UI_TABS_TAB_STRIP_MODEL_H_
      6 #define CHROME_BROWSER_UI_TABS_TAB_STRIP_MODEL_H_
      7 
      8 #include <vector>
      9 
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/observer_list.h"
     12 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
     13 #include "content/public/common/page_transition_types.h"
     14 #include "ui/base/models/list_selection_model.h"
     15 
     16 class Profile;
     17 class TabStripModelDelegate;
     18 class TabStripModelOrderController;
     19 
     20 namespace content {
     21 class WebContents;
     22 }
     23 
     24 ////////////////////////////////////////////////////////////////////////////////
     25 //
     26 // TabStripModel
     27 //
     28 //  A model & low level controller of a Browser Window tabstrip. Holds a vector
     29 //  of WebContentses, and provides an API for adding, removing and
     30 //  shuffling them, as well as a higher level API for doing specific Browser-
     31 //  related tasks like adding new Tabs from just a URL, etc.
     32 //
     33 // Each tab may be any one of the following states:
     34 // . Mini-tab. Mini tabs are locked to the left side of the tab strip and
     35 //   rendered differently (small tabs with only a favicon). The model makes
     36 //   sure all mini-tabs are at the beginning of the tab strip. For example,
     37 //   if a non-mini tab is added it is forced to be with non-mini tabs. Requests
     38 //   to move tabs outside the range of the tab type are ignored. For example,
     39 //   a request to move a mini-tab after non-mini-tabs is ignored.
     40 //   You'll notice there is no explicit api for making a tab a mini-tab, rather
     41 //   there are two tab types that are implicitly mini-tabs:
     42 //   . App. Corresponds to an extension that wants an app tab. App tabs are
     43 //     identified by extensions::TabHelper::is_app().
     44 //     App tabs are always pinned (you can't unpin them).
     45 //   . Pinned. Any tab can be pinned. Non-app tabs whose pinned state is changed
     46 //     are moved to be with other mini-tabs or non-mini tabs.
     47 //
     48 //  A TabStripModel has one delegate that it relies on to perform certain tasks
     49 //  like creating new TabStripModels (probably hosted in Browser windows) when
     50 //  required. See TabStripDelegate above for more information.
     51 //
     52 //  A TabStripModel also has N observers (see TabStripModelObserver above),
     53 //  which can be registered via Add/RemoveObserver. An Observer is notified of
     54 //  tab creations, removals, moves, and other interesting events. The
     55 //  TabStrip implements this interface to know when to create new tabs in
     56 //  the View, and the Browser object likewise implements to be able to update
     57 //  its bookkeeping when such events happen.
     58 //
     59 ////////////////////////////////////////////////////////////////////////////////
     60 class TabStripModel {
     61  public:
     62   // Used to specify what should happen when the tab is closed.
     63   enum CloseTypes {
     64     CLOSE_NONE                     = 0,
     65 
     66     // Indicates the tab was closed by the user. If true,
     67     // WebContents::SetClosedByUserGesture(true) is invoked.
     68     CLOSE_USER_GESTURE             = 1 << 0,
     69 
     70     // If true the history is recorded so that the tab can be reopened later.
     71     // You almost always want to set this.
     72     CLOSE_CREATE_HISTORICAL_TAB    = 1 << 1,
     73   };
     74 
     75   // Constants used when adding tabs.
     76   enum AddTabTypes {
     77     // Used to indicate nothing special should happen to the newly inserted
     78     // tab.
     79     ADD_NONE          = 0,
     80 
     81     // The tab should be active.
     82     ADD_ACTIVE        = 1 << 0,
     83 
     84     // The tab should be pinned.
     85     ADD_PINNED        = 1 << 1,
     86 
     87     // If not set the insertion index of the WebContents is left up to
     88     // the Order Controller associated, so the final insertion index may differ
     89     // from the specified index. Otherwise the index supplied is used.
     90     ADD_FORCE_INDEX   = 1 << 2,
     91 
     92     // If set the newly inserted tab inherits the group of the currently
     93     // selected tab. If not set the tab may still inherit the group under
     94     // certain situations.
     95     ADD_INHERIT_GROUP = 1 << 3,
     96 
     97     // If set the newly inserted tab's opener is set to the active tab. If not
     98     // set the tab may still inherit the group/opener under certain situations.
     99     // NOTE: this is ignored if ADD_INHERIT_GROUP is set.
    100     ADD_INHERIT_OPENER = 1 << 4,
    101   };
    102 
    103   // Enumerates different ways to open a new tab. Does not apply to opening
    104   // existing links or searches in a new tab, only to brand new empty tabs.
    105   enum NewTab {
    106     // New tab was opened using the new tab button on the tab strip.
    107     NEW_TAB_BUTTON,
    108 
    109     // New tab was opened using the menu command - either through the keyboard
    110     // shortcut, or by opening the menu and selecting the command. Applies to
    111     // both Wrench menu and the menu bar's File menu (on platforms that have
    112     // one).
    113     NEW_TAB_COMMAND,
    114 
    115     // New tab was opened through the context menu on the tab strip.
    116     NEW_TAB_CONTEXT_MENU,
    117 
    118     // Number of enum entries, used for UMA histogram reporting macros.
    119     NEW_TAB_ENUM_COUNT,
    120   };
    121 
    122   static const int kNoTab = -1;
    123 
    124   // Construct a TabStripModel with a delegate to help it do certain things
    125   // (see the TabStripModelDelegate documentation). |delegate| cannot be NULL.
    126   TabStripModel(TabStripModelDelegate* delegate, Profile* profile);
    127   virtual ~TabStripModel();
    128 
    129   // Retrieves the TabStripModelDelegate associated with this TabStripModel.
    130   TabStripModelDelegate* delegate() const { return delegate_; }
    131 
    132   // Add and remove observers to changes within this TabStripModel.
    133   void AddObserver(TabStripModelObserver* observer);
    134   void RemoveObserver(TabStripModelObserver* observer);
    135 
    136   // Retrieve the number of WebContentses/emptiness of the TabStripModel.
    137   int count() const { return static_cast<int>(contents_data_.size()); }
    138   bool empty() const { return contents_data_.empty(); }
    139 
    140   // Retrieve the Profile associated with this TabStripModel.
    141   Profile* profile() const { return profile_; }
    142 
    143   // Retrieve the index of the currently active WebContents.
    144   int active_index() const { return selection_model_.active(); }
    145 
    146   // Returns true if the tabstrip is currently closing all open tabs (via a
    147   // call to CloseAllTabs). As tabs close, the selection in the tabstrip
    148   // changes which notifies observers, which can use this as an optimization to
    149   // avoid doing meaningless or unhelpful work.
    150   bool closing_all() const { return closing_all_; }
    151 
    152   // Access the order controller. Exposed only for unit tests.
    153   TabStripModelOrderController* order_controller() const {
    154     return order_controller_.get();
    155   }
    156 
    157   // Basic API /////////////////////////////////////////////////////////////////
    158 
    159   // Determines if the specified index is contained within the TabStripModel.
    160   bool ContainsIndex(int index) const;
    161 
    162   // Adds the specified WebContents in the default location. Tabs opened
    163   // in the foreground inherit the group of the previously active tab.
    164   void AppendWebContents(content::WebContents* contents, bool foreground);
    165 
    166   // Adds the specified WebContents at the specified location.
    167   // |add_types| is a bitmask of AddTabTypes; see it for details.
    168   //
    169   // All append/insert methods end up in this method.
    170   //
    171   // NOTE: adding a tab using this method does NOT query the order controller,
    172   // as such the ADD_FORCE_INDEX AddTabTypes is meaningless here.  The only time
    173   // the |index| is changed is if using the index would result in breaking the
    174   // constraint that all mini-tabs occur before non-mini-tabs.
    175   // See also AddWebContents.
    176   void InsertWebContentsAt(int index,
    177                            content::WebContents* contents,
    178                            int add_types);
    179 
    180   // Closes the WebContents at the specified index. This causes the
    181   // WebContents to be destroyed, but it may not happen immediately.
    182   // |close_types| is a bitmask of CloseTypes. Returns true if the
    183   // WebContents was closed immediately, false if it was not closed (we
    184   // may be waiting for a response from an onunload handler, or waiting for the
    185   // user to confirm closure).
    186   bool CloseWebContentsAt(int index, uint32 close_types);
    187 
    188   // Replaces the WebContents at |index| with |new_contents|. The
    189   // WebContents that was at |index| is returned and its ownership returns
    190   // to the caller.
    191   content::WebContents* ReplaceWebContentsAt(
    192       int index,
    193       content::WebContents* new_contents);
    194 
    195   // Destroys the WebContents at the specified index, but keeps the tab
    196   // visible in the tab strip. Used to free memory in low-memory conditions,
    197   // especially on Chrome OS. The tab reloads if the user clicks on it.
    198   // Returns the new empty WebContents, used only for testing.
    199   content::WebContents* DiscardWebContentsAt(int index);
    200 
    201   // Detaches the WebContents at the specified index from this strip. The
    202   // WebContents is not destroyed, just removed from display. The caller
    203   // is responsible for doing something with it (e.g. stuffing it into another
    204   // strip). Returns the detached WebContents.
    205   content::WebContents* DetachWebContentsAt(int index);
    206 
    207   // Makes the tab at the specified index the active tab. |user_gesture| is true
    208   // if the user actually clicked on the tab or navigated to it using a keyboard
    209   // command, false if the tab was activated as a by-product of some other
    210   // action.
    211   void ActivateTabAt(int index, bool user_gesture);
    212 
    213   // Adds tab at |index| to the currently selected tabs, without changing the
    214   // active tab index.
    215   void AddTabAtToSelection(int index);
    216 
    217   // Move the WebContents at the specified index to another index. This
    218   // method does NOT send Detached/Attached notifications, rather it moves the
    219   // WebContents inline and sends a Moved notification instead.
    220   // If |select_after_move| is false, whatever tab was selected before the move
    221   // will still be selected, but its index may have incremented or decremented
    222   // one slot.
    223   // NOTE: This respects basic ordering constraints and thus does nothing if the
    224   // move would result in app tabs and non-app tabs mixing.
    225   void MoveWebContentsAt(int index, int to_position, bool select_after_move);
    226 
    227   // Moves the selected tabs to |index|. |index| is treated as if the tab strip
    228   // did not contain any of the selected tabs. For example, if the tabstrip
    229   // contains [A b c D E f] (upper case selected) and this is invoked with 1 the
    230   // result is [b A D E c f].
    231   // This method maintains that all mini-tabs occur before non-mini-tabs.  When
    232   // mini-tabs are selected the move is processed in two chunks: first mini-tabs
    233   // are moved, then non-mini-tabs are moved. If the index is after
    234   // (mini-tab-count - selected-mini-tab-count), then the index the non-mini
    235   // selected tabs are moved to is (index + selected-mini-tab-count). For
    236   // example, if the model consists of [A b c D E f] (A b c are mini) and this
    237   // is invoked with 2, the result is [b c A D E f]. In this example nothing
    238   // special happened because the target index was <= (mini-tab-count -
    239   // selected-mini-tab-count). If the target index were 3, then the result would
    240   // be [b c A f D F]. A, being mini, can move no further than index 2. The
    241   // non-mini-tabs are moved to the target index + selected-mini-tab-count (3 +
    242   // 1)
    243   void MoveSelectedTabsTo(int index);
    244 
    245   // Returns the currently active WebContents, or NULL if there is none.
    246   content::WebContents* GetActiveWebContents() const;
    247 
    248   // Returns the WebContents at the specified index, or NULL if there is
    249   // none.
    250   content::WebContents* GetWebContentsAt(int index) const;
    251 
    252   // Returns the index of the specified WebContents, or TabStripModel::kNoTab
    253   // if the WebContents is not in this TabStripModel.
    254   int GetIndexOfWebContents(const content::WebContents* contents) const;
    255 
    256   // Notify any observers that the WebContents at the specified index has
    257   // changed in some way. See TabChangeType for details of |change_type|.
    258   void UpdateWebContentsStateAt(
    259       int index,
    260       TabStripModelObserver::TabChangeType change_type);
    261 
    262   // Close all tabs at once. Code can use closing_all() above to defer
    263   // operations that might otherwise by invoked by the flurry of detach/select
    264   // notifications this method causes.
    265   void CloseAllTabs();
    266 
    267   // Returns true if there are any WebContentses that are currently loading.
    268   bool TabsAreLoading() const;
    269 
    270   // Returns the WebContents that opened the WebContents at |index|, or NULL if
    271   // there is no opener on record.
    272   content::WebContents* GetOpenerOfWebContentsAt(int index);
    273 
    274   // Changes the |opener| of the WebContents at |index|.
    275   // Note: |opener| must be in this tab strip.
    276   void SetOpenerOfWebContentsAt(int index, content::WebContents* opener);
    277 
    278   // Returns the index of the next WebContents in the sequence of WebContentses
    279   // spawned by the specified WebContents after |start_index|. If |use_group| is
    280   // true, the group property of the tab is used instead of the opener to find
    281   // the next tab. Under some circumstances the group relationship may exist but
    282   // the opener may not.
    283   int GetIndexOfNextWebContentsOpenedBy(const content::WebContents* opener,
    284                                         int start_index,
    285                                         bool use_group) const;
    286 
    287   // Returns the index of the last WebContents in the model opened by the
    288   // specified opener, starting at |start_index|.
    289   int GetIndexOfLastWebContentsOpenedBy(const content::WebContents* opener,
    290                                         int start_index) const;
    291 
    292   // To be called when a navigation is about to occur in the specified
    293   // WebContents. Depending on the tab, and the transition type of the
    294   // navigation, the TabStripModel may adjust its selection and grouping
    295   // behavior.
    296   void TabNavigating(content::WebContents* contents,
    297                      content::PageTransition transition);
    298 
    299   // Forget all Opener relationships that are stored (but _not_ group
    300   // relationships!) This is to reduce unpredictable tab switching behavior
    301   // in complex session states. The exact circumstances under which this method
    302   // is called are left up to the implementation of the selected
    303   // TabStripModelOrderController.
    304   void ForgetAllOpeners();
    305 
    306   // Forgets the group affiliation of the specified WebContents. This
    307   // should be called when a WebContents that is part of a logical group
    308   // of tabs is moved to a new logical context by the user (e.g. by typing a new
    309   // URL or selecting a bookmark). This also forgets the opener, which is
    310   // considered a weaker relationship than group.
    311   void ForgetGroup(content::WebContents* contents);
    312 
    313   // Returns true if the group/opener relationships present for |contents|
    314   // should be reset when _any_ selection change occurs in the model.
    315   bool ShouldResetGroupOnSelect(content::WebContents* contents) const;
    316 
    317   // Changes the blocked state of the tab at |index|.
    318   void SetTabBlocked(int index, bool blocked);
    319 
    320   // Changes the pinned state of the tab at |index|. See description above
    321   // class for details on this.
    322   void SetTabPinned(int index, bool pinned);
    323 
    324   // Returns true if the tab at |index| is pinned.
    325   // See description above class for details on pinned tabs.
    326   bool IsTabPinned(int index) const;
    327 
    328   // Is the tab a mini-tab?
    329   // See description above class for details on this.
    330   bool IsMiniTab(int index) const;
    331 
    332   // Is the tab at |index| an app?
    333   // See description above class for details on app tabs.
    334   bool IsAppTab(int index) const;
    335 
    336   // Returns true if the tab at |index| is blocked by a tab modal dialog.
    337   bool IsTabBlocked(int index) const;
    338 
    339   // Returns true if the WebContents at |index| has been discarded to
    340   // save memory.  See DiscardWebContentsAt() for details.
    341   bool IsTabDiscarded(int index) const;
    342 
    343   // Returns the index of the first tab that is not a mini-tab. This returns
    344   // |count()| if all of the tabs are mini-tabs, and 0 if none of the tabs are
    345   // mini-tabs.
    346   int IndexOfFirstNonMiniTab() const;
    347 
    348   // Returns a valid index for inserting a new tab into this model. |index| is
    349   // the proposed index and |mini_tab| is true if inserting a tab will become
    350   // mini (pinned or app). If |mini_tab| is true, the returned index is between
    351   // 0 and IndexOfFirstNonMiniTab. If |mini_tab| is false, the returned index
    352   // is between IndexOfFirstNonMiniTab and count().
    353   int ConstrainInsertionIndex(int index, bool mini_tab);
    354 
    355   // Extends the selection from the anchor to |index|.
    356   void ExtendSelectionTo(int index);
    357 
    358   // Toggles the selection at |index|. This does nothing if |index| is selected
    359   // and there are no other selected tabs.
    360   void ToggleSelectionAt(int index);
    361 
    362   // Makes sure the tabs from the anchor to |index| are selected. This only
    363   // adds to the selection.
    364   void AddSelectionFromAnchorTo(int index);
    365 
    366   // Returns true if the tab at |index| is selected.
    367   bool IsTabSelected(int index) const;
    368 
    369   // Sets the selection to match that of |source|.
    370   void SetSelectionFromModel(const ui::ListSelectionModel& source);
    371 
    372   const ui::ListSelectionModel& selection_model() const {
    373     return selection_model_;
    374   }
    375 
    376   // Command level API /////////////////////////////////////////////////////////
    377 
    378   // Adds a WebContents at the best position in the TabStripModel given
    379   // the specified insertion index, transition, etc. |add_types| is a bitmask of
    380   // AddTabTypes; see it for details. This method ends up calling into
    381   // InsertWebContentsAt to do the actual insertion. Pass kNoTab for |index| to
    382   // append the contents to the end of the tab strip.
    383   void AddWebContents(content::WebContents* contents,
    384                       int index,
    385                       content::PageTransition transition,
    386                       int add_types);
    387 
    388   // Closes the selected tabs.
    389   void CloseSelectedTabs();
    390 
    391   // Select adjacent tabs
    392   void SelectNextTab();
    393   void SelectPreviousTab();
    394 
    395   // Selects the last tab in the tab strip.
    396   void SelectLastTab();
    397 
    398   // Swap adjacent tabs.
    399   void MoveTabNext();
    400   void MoveTabPrevious();
    401 
    402   // View API //////////////////////////////////////////////////////////////////
    403 
    404   // Context menu functions.
    405   enum ContextMenuCommand {
    406     CommandFirst = 0,
    407     CommandNewTab,
    408     CommandReload,
    409     CommandDuplicate,
    410     CommandCloseTab,
    411     CommandCloseOtherTabs,
    412     CommandCloseTabsToRight,
    413     CommandRestoreTab,
    414     CommandTogglePinned,
    415     CommandBookmarkAllTabs,
    416     CommandSelectByDomain,
    417     CommandSelectByOpener,
    418     CommandLast
    419   };
    420 
    421   // Returns true if the specified command is enabled. If |context_index| is
    422   // selected the response applies to all selected tabs.
    423   bool IsContextMenuCommandEnabled(int context_index,
    424                                    ContextMenuCommand command_id) const;
    425 
    426   // Performs the action associated with the specified command for the given
    427   // TabStripModel index |context_index|.  If |context_index| is selected the
    428   // command applies to all selected tabs.
    429   void ExecuteContextMenuCommand(int context_index,
    430                                  ContextMenuCommand command_id);
    431 
    432   // Returns a vector of indices of the tabs that will close when executing the
    433   // command |id| for the tab at |index|. The returned indices are sorted in
    434   // descending order.
    435   std::vector<int> GetIndicesClosedByCommand(int index,
    436                                              ContextMenuCommand id) const;
    437 
    438   // Returns true if 'CommandTogglePinned' will pin. |index| is the index
    439   // supplied to |ExecuteContextMenuCommand|.
    440   bool WillContextMenuPin(int index);
    441 
    442   // Convert a ContextMenuCommand into a browser command. Returns true if a
    443   // corresponding browser command exists, false otherwise.
    444   static bool ContextMenuCommandToBrowserCommand(int cmd_id, int* browser_cmd);
    445 
    446  private:
    447   class WebContentsData;
    448 
    449   // Used when making selection notifications.
    450   enum NotifyTypes {
    451     NOTIFY_DEFAULT,
    452 
    453     // The selection is changing from a user gesture.
    454     NOTIFY_USER_GESTURE,
    455   };
    456 
    457   // Convenience for converting a vector of indices into a vector of
    458   // WebContents.
    459   std::vector<content::WebContents*> GetWebContentsFromIndices(
    460       const std::vector<int>& indices) const;
    461 
    462   // Gets the set of tab indices whose domain matches the tab at |index|.
    463   void GetIndicesWithSameDomain(int index, std::vector<int>* indices);
    464 
    465   // Gets the set of tab indices that have the same opener as the tab at
    466   // |index|.
    467   void GetIndicesWithSameOpener(int index, std::vector<int>* indices);
    468 
    469   // If |index| is selected all the selected indices are returned, otherwise a
    470   // vector with |index| is returned. This is used when executing commands to
    471   // determine which indices the command applies to.
    472   std::vector<int> GetIndicesForCommand(int index) const;
    473 
    474   // Returns true if the specified WebContents is a New Tab at the end of
    475   // the tabstrip. We check for this because opener relationships are _not_
    476   // forgotten for the New Tab page opened as a result of a New Tab gesture
    477   // (e.g. Ctrl+T, etc) since the user may open a tab transiently to look up
    478   // something related to their current activity.
    479   bool IsNewTabAtEndOfTabStrip(content::WebContents* contents) const;
    480 
    481   // Closes the WebContentses at the specified indices. This causes the
    482   // WebContentses to be destroyed, but it may not happen immediately. If
    483   // the page in question has an unload event the WebContents will not be
    484   // destroyed until after the event has completed, which will then call back
    485   // into this method.
    486   //
    487   // Returns true if the WebContentses were closed immediately, false if we
    488   // are waiting for the result of an onunload handler.
    489   bool InternalCloseTabs(const std::vector<int>& indices,
    490                          uint32 close_types);
    491 
    492   // Invoked from InternalCloseTabs and when an extension is removed for an app
    493   // tab. Notifies observers of TabClosingAt and deletes |contents|. If
    494   // |create_historical_tabs| is true, CreateHistoricalTab is invoked on the
    495   // delegate.
    496   //
    497   // The boolean parameter create_historical_tab controls whether to
    498   // record these tabs and their history for reopening recently closed
    499   // tabs.
    500   void InternalCloseTab(content::WebContents* contents,
    501                         int index,
    502                         bool create_historical_tabs);
    503 
    504   // Gets the WebContents at an index. Does no bounds checking.
    505   content::WebContents* GetWebContentsAtImpl(int index) const;
    506 
    507   // Notifies the observers if the active tab is being deactivated.
    508   void NotifyIfTabDeactivated(content::WebContents* contents);
    509 
    510   // Notifies the observers if the active tab has changed.
    511   void NotifyIfActiveTabChanged(content::WebContents* old_contents,
    512                                 NotifyTypes notify_types);
    513 
    514   // Notifies the observers if the active tab or the tab selection has changed.
    515   // |old_model| is a snapshot of |selection_model_| before the change.
    516   // Note: This function might end up sending 0 to 2 notifications in the
    517   // following order: ActiveTabChanged, TabSelectionChanged.
    518   void NotifyIfActiveOrSelectionChanged(
    519       content::WebContents* old_contents,
    520       NotifyTypes notify_types,
    521       const ui::ListSelectionModel& old_model);
    522 
    523   // Sets the selection to |new_model| and notifies any observers.
    524   // Note: This function might end up sending 0 to 3 notifications in the
    525   // following order: TabDeactivated, ActiveTabChanged, TabSelectionChanged.
    526   void SetSelection(const ui::ListSelectionModel& new_model,
    527                     NotifyTypes notify_types);
    528 
    529   // Selects either the next tab (|forward| is true), or the previous tab
    530   // (|forward| is false).
    531   void SelectRelativeTab(bool forward);
    532 
    533   // Does the work of MoveWebContentsAt. This has no checks to make sure the
    534   // position is valid, those are done in MoveWebContentsAt.
    535   void MoveWebContentsAtImpl(int index,
    536                              int to_position,
    537                              bool select_after_move);
    538 
    539   // Implementation of MoveSelectedTabsTo. Moves |length| of the selected tabs
    540   // starting at |start| to |index|. See MoveSelectedTabsTo for more details.
    541   void MoveSelectedTabsToImpl(int index, size_t start, size_t length);
    542 
    543   // Returns true if the tab represented by the specified data has an opener
    544   // that matches the specified one. If |use_group| is true, then this will
    545   // fall back to check the group relationship as well.
    546   static bool OpenerMatches(const WebContentsData* data,
    547                             const content::WebContents* opener,
    548                             bool use_group);
    549 
    550   // Sets the group/opener of any tabs that reference |tab| to NULL.
    551   void ForgetOpenersAndGroupsReferencing(const content::WebContents* tab);
    552 
    553   // Our delegate.
    554   TabStripModelDelegate* delegate_;
    555 
    556   // The WebContents data currently hosted within this TabStripModel.
    557   typedef std::vector<WebContentsData*> WebContentsDataVector;
    558   WebContentsDataVector contents_data_;
    559 
    560   // A profile associated with this TabStripModel.
    561   Profile* profile_;
    562 
    563   // True if all tabs are currently being closed via CloseAllTabs.
    564   bool closing_all_;
    565 
    566   // An object that determines where new Tabs should be inserted and where
    567   // selection should move when a Tab is closed.
    568   scoped_ptr<TabStripModelOrderController> order_controller_;
    569 
    570   // Our observers.
    571   typedef ObserverList<TabStripModelObserver> TabStripModelObservers;
    572   TabStripModelObservers observers_;
    573 
    574   ui::ListSelectionModel selection_model_;
    575 
    576   // TODO(sky): remove this; used for debugging 291265.
    577   bool in_notify_;
    578 
    579   DISALLOW_IMPLICIT_CONSTRUCTORS(TabStripModel);
    580 };
    581 
    582 #endif  // CHROME_BROWSER_UI_TABS_TAB_STRIP_MODEL_H_
    583