Make pink's TabContentsWrapper change compile on Windows....

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_
 #pragma once
 
 #include <vector>
 
 #include "base/observer_list.h"
 #include "chrome/browser/tabs/tab_strip_model_observer.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/page_transition_types.h"
 
 class NavigationController;
 class Profile;
 class TabContents;
+class TabContentsWrapper;
 class TabStripModelDelegate;
 class TabStripModelOrderController;
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TabStripModel
 //
 //  A model & low level controller of a Browser Window tabstrip. Holds a vector
 //  of TabContents, and provides an API for adding, removing and shuffling
 //  them, as well as a higher level API for doing specific Browser-related
@@ skipping 122 matching lines @@
   // for debugging.
   bool HasObserver(TabStripModelObserver* observer);
 
   // Basic API /////////////////////////////////////////////////////////////////
 
   // Determines if the specified index is contained within the TabStripModel.
   bool ContainsIndex(int index) const;
 
   // Adds the specified TabContents in the default location. Tabs opened in the
   // foreground inherit the group of the previously selected tab.
-  void AppendTabContents(TabContents* contents, bool foreground);
+  void AppendTabContents(TabContentsWrapper* contents, bool foreground);
 
   // Adds the specified TabContents at the specified location. |add_types| is a
   // bitmask of AddTypes; see it for details.
   //
   // All append/insert methods end up in this method.
   //
   // NOTE: adding a tab using this method does NOT query the order controller,
   // as such the ADD_FORCE_INDEX AddType is meaningless here.  The only time the
   // |index| is changed is if using the index would result in breaking the
   // constraint that all mini-tabs occur before non-mini-tabs.
   // See also AddTabContents.
   void InsertTabContentsAt(int index,
-                           TabContents* contents,
+                           TabContentsWrapper* contents,
                            int add_types);
 
   // Closes the TabContents at the specified index. This causes the TabContents
   // to be destroyed, but it may not happen immediately (e.g. if it's a
   // TabContents). |close_types| is a bitmask of CloseTypes.
   // Returns true if the TabContents was closed immediately, false if it was not
   // closed (we may be waiting for a response from an onunload handler, or
   // waiting for the user to confirm closure).
   bool CloseTabContentsAt(int index, uint32 close_types);
 
   // Replaces the entire state of a the tab at index by switching in a
   // different NavigationController. This is used through the recently
   // closed tabs list, which needs to replace a tab's current state
   // and history with another set of contents and history.
   //
   // The old NavigationController is deallocated and this object takes
   // ownership of the passed in controller.
+  // XXXPINK This API is weird and wrong. Remove it or change it or rename it?
   void ReplaceNavigationControllerAt(int index,
-                                     NavigationController* controller);
+                                     TabContentsWrapper* contents);
 
   // Replaces the tab contents at |index| with |new_contents|. This deletes the
   // TabContents currently at |index|.
-  void ReplaceTabContentsAt(int index, TabContents* new_contents);
+  void ReplaceTabContentsAt(int index, TabContentsWrapper* new_contents);
 
   // Detaches the TabContents at the specified index from this strip. The
   // TabContents is not destroyed, just removed from display. The caller is
   // responsible for doing something with it (e.g. stuffing it into another
   // strip).
-  TabContents* DetachTabContentsAt(int index);
+  TabContentsWrapper* DetachTabContentsAt(int index);
 
   // Select the TabContents at the specified index. |user_gesture| is true if
   // the user actually clicked on the tab or navigated to it using a keyboard
   // command, false if the tab was selected as a by-product of some other
   // action.
   void SelectTabContentsAt(int index, bool user_gesture);
 
   // Move the TabContents at the specified index to another index. This method
   // does NOT send Detached/Attached notifications, rather it moves the
   // TabContents inline and sends a Moved notification instead.
   // If |select_after_move| is false, whatever tab was selected before the move
   // will still be selected, but it's index may have incremented or decremented
   // one slot.
   // NOTE: this does nothing if the move would result in app tabs and non-app
   // tabs mixing.
   void MoveTabContentsAt(int index, int to_position, bool select_after_move);
 
   // Returns the currently selected TabContents, or NULL if there is none.
-  TabContents* GetSelectedTabContents() const;
+  TabContentsWrapper* GetSelectedTabContents() const;
 
-  // Returns the TabContents at the specified index, or NULL if there is none.
-  TabContents* GetTabContentsAt(int index) const;
+  // Returns the TabContentsWrapper at the specified index, or NULL if there is
+  // none.
+  TabContentsWrapper* GetTabContentsAt(int index) const;
 
-  // Returns the index of the specified TabContents, or TabContents::kNoTab if
-  // the TabContents is not in this TabStripModel.
-  int GetIndexOfTabContents(const TabContents* contents) const;
+  // Returns the index of the specified TabContents wrapper, or
+  // TabStripModel::kNoTab if the TabContents is not in this TabStripModel.
+  int GetIndexOfTabContents(const TabContentsWrapper* contents) const;
 
-  // Returns the index of the specified NavigationController, or -1 if it is
+  // Returns the index of the specified TabContents wrapper given its raw
+  // TabContents, or TabStripModel::kNoTab if the TabContents is not in this
+  // TabStripModel.  Note: This is only needed in rare cases where the wrapper
+  // is not already present (such as implementing TabContentsDelegate methods,
+  // which don't know about the wrapper.  Returns NULL if |contents| is not
+  // associated with any wrapper in the model.
+  int GetWrapperIndex(const TabContents* contents) const;
+
+  // Returns the index of the specified NavigationController, or kNoTab if it is
   // not in this TabStripModel.
   int GetIndexOfController(const NavigationController* controller) const;
 
   // Notify any observers that the TabContents at the specified index has
   // changed in some way. See TabChangeType for details of |change_type|.
   void UpdateTabContentsStateAt(
       int index,
       TabStripModelObserver::TabChangeType change_type);
 
   // Make sure there is an auto-generated New Tab tab in the TabStripModel.
@@ skipping 28 matching lines @@
 
   // Returns the index of the last TabContents in the model opened by the
   // specified opener, starting at |start_index|.
   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);
+  void TabNavigating(TabContentsWrapper* contents,
+                     PageTransition::Type transition);
 
   // Forget all Opener relationships that are stored (but _not_ group
   // relationships!) This is to reduce unpredictable tab switching behavior
   // in complex session states. The exact circumstances under which this method
   // is called are left up to the implementation of the selected
   // TabStripModelOrderController.
   void ForgetAllOpeners();
 
   // Forgets the group affiliation of the specified TabContents. This should be
   // called when a TabContents that is part of a logical group of tabs is
   // moved to a new logical context by the user (e.g. by typing a new URL or
   // selecting a bookmark). This also forgets the opener, which is considered
   // a weaker relationship than group.
-  void ForgetGroup(TabContents* contents);
+  void ForgetGroup(TabContentsWrapper* contents);
 
   // Returns true if the group/opener relationships present for |contents|
   // should be reset when _any_ selection change occurs in the model.
-  bool ShouldResetGroupOnSelect(TabContents* contents) const;
+  bool ShouldResetGroupOnSelect(TabContentsWrapper* contents) const;
 
   // Changes the blocked state of the tab at |index|.
   void SetTabBlocked(int index, bool blocked);
 
   // Changes the pinned state of the tab at |index|. See description above
   // class for details on this.
   void SetTabPinned(int index, bool pinned);
 
   // Returns true if the tab at |index| is pinned.
   // See description above class for details on pinned tabs.
@@ skipping 21 matching lines @@
   // 0 and IndexOfFirstNonMiniTab. If |mini_tab| is false, the returned index
   // is between IndexOfFirstNonMiniTab and count().
   int ConstrainInsertionIndex(int index, bool mini_tab);
 
   // Command level API /////////////////////////////////////////////////////////
 
   // Adds a TabContents at the best position in the TabStripModel given the
   // specified insertion index, transition, etc. |add_types| is a bitmask of
   // AddTypes; see it for details. This method ends up calling into
   // InsertTabContentsAt to do the actual inertion.
-  void AddTabContents(TabContents* contents,
+  void AddTabContents(TabContentsWrapper* contents,
                       int index,
                       PageTransition::Type transition,
                       int add_types);
 
   // Closes the selected TabContents.
   void CloseSelectedTab();
 
   // Select adjacent tabs
   void SelectNextTab();
   void SelectPreviousTab();
@@ skipping 49 matching lines @@
 
  private:
   // We cannot be constructed without a delegate.
   TabStripModel();
 
   // Returns true if the specified TabContents is a New Tab at the end of the
   // TabStrip. We check for this because opener relationships are _not_
   // forgotten for the New Tab page opened as a result of a New Tab gesture
   // (e.g. Ctrl+T, etc) since the user may open a tab transiently to look up
   // something related to their current activity.
-  bool IsNewTabAtEndOfTabStrip(TabContents* contents) const;
+  bool IsNewTabAtEndOfTabStrip(TabContentsWrapper* contents) const;
 
   // Closes the TabContents at the specified indices. This causes the
   // TabContents to be destroyed, but it may not happen immediately.  If the
   // page in question has an unload event the TabContents will not be destroyed
   // until after the event has completed, which will then call back into this
   // method.
   //
   // Returns true if the TabContents were closed immediately, false if we are
   // waiting for the result of an onunload handler.
   bool InternalCloseTabs(const std::vector<int>& indices, uint32 close_types);
 
   // Invoked from InternalCloseTabs and when an extension is removed for an app
   // tab. Notifies observers of TabClosingAt and deletes |contents|. If
   // |create_historical_tabs| is true, CreateHistoricalTab is invoked on the
   // delegate.
   //
   // The boolean parameter create_historical_tab controls whether to
   // record these tabs and their history for reopening recently closed
   // tabs.
-  void InternalCloseTab(TabContents* contents,
+  void InternalCloseTab(TabContentsWrapper* contents,
                         int index,
                         bool create_historical_tabs);
 
-  TabContents* GetContentsAt(int index) const;
+  TabContentsWrapper* GetContentsAt(int index) const;
 
   // The actual implementation of SelectTabContentsAt. Takes the previously
   // selected contents in |old_contents|, which may actually not be in
   // |contents_| anymore because it may have been removed by a call to say
   // DetachTabContentsAt...
   void ChangeSelectedContentsFrom(
-      TabContents* old_contents, int to_index, bool user_gesture);
+      TabContentsWrapper* old_contents, int to_index, bool user_gesture);
 
   // Returns the number of New Tab tabs in the TabStripModel.
   int GetNewTabCount() const;
 
   // Selects either the next tab (|foward| is true), or the previous tab
   // (|forward| is false).
   void SelectRelativeTab(bool forward);
 
   // Does the work of MoveTabContentsAt. This has no checks to make sure the
   // position is valid, those are done in MoveTabContentsAt.
@@ skipping 10 matching lines @@
                             bool use_group);
 
   // Our delegate.
   TabStripModelDelegate* delegate_;
 
   // A hunk of data representing a TabContents and (optionally) the
   // NavigationController that spawned it. This memory only sticks around while
   // the TabContents is in the current TabStripModel, unless otherwise
   // specified in code.
   struct TabContentsData {
-    explicit TabContentsData(TabContents* a_contents)
+    explicit TabContentsData(TabContentsWrapper* a_contents)
         : contents(a_contents),
           reset_group_on_select(false),
           pinned(false),
           blocked(false) {
       SetGroup(NULL);
     }
 
     // Create a relationship between this TabContents and other TabContentses.
     // Used to identify which TabContents to select next after one is closed.
     void SetGroup(NavigationController* a_group) {
       group = a_group;
       opener = a_group;
     }
 
     // Forget the opener relationship so that when this TabContents is closed
     // unpredictable re-selection does not occur.
     void ForgetOpener() {
       opener = NULL;
     }
 
-    TabContents* contents;
+    TabContentsWrapper* contents;
     // We use NavigationControllers here since they more closely model the
     // "identity" of a Tab, TabContents can change depending on the URL loaded
     // in the Tab.
     // The group is used to model a set of tabs spawned from a single parent
     // tab. This value is preserved for a given tab as long as the tab remains
     // navigated to the link it was initially opened at or some navigation from
     // that page (i.e. if the user types or visits a bookmark or some other
     // navigation within that tab, the group relationship is lost). This
     // property can safely be used to implement features that depend on a
     // logical group of related tabs.
@@ skipping 39 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_