Convert WebContents to return a content::NavigationController instead of the implementation. Upda...

chrome/browser/tabs/tab_strip_model.h

 // Copyright (c) 2011 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/browser/tabs/tab_strip_selection_model.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/common/page_transition_types.h"
 
-class NavigationController;
 class Profile;
 class TabContents;
 class TabContentsWrapper;
 class TabStripModelDelegate;
 class TabStripModelOrderController;
 
 namespace content {
 class NavigationController;
 class WebContents;
 }
@@ skipping 264 matching lines @@
 
   // Close all tabs at once. Code can use closing_all() above to defer
   // operations that might otherwise by invoked by the flurry of detach/select
   // notifications this method causes.
   void CloseAllTabs();
 
   // Returns true if there are any TabContents that are currently loading.
   bool TabsAreLoading() const;
 
   // Returns the controller controller that opened the TabContents at |index|.
-  NavigationController* GetOpenerOfTabContentsAt(int index);
+  content::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.
-  int GetIndexOfNextTabContentsOpenedBy(const NavigationController* opener,
-                                        int start_index,
-                                        bool use_group) const;
+  int GetIndexOfNextTabContentsOpenedBy(
+      const content::NavigationController* opener,
+      int start_index,
+      bool use_group) const;
 
   // Returns the index of the first TabContents in the model opened by the
   // specified opener.
-  int GetIndexOfFirstTabContentsOpenedBy(const NavigationController* opener,
-                                         int start_index) const;
+  int GetIndexOfFirstTabContentsOpenedBy(
+      const content::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|.
-  int GetIndexOfLastTabContentsOpenedBy(const NavigationController* opener,
-                                        int start_index) const;
+  int GetIndexOfLastTabContentsOpenedBy(
+      const content::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(TabContentsWrapper* contents,
                      content::PageTransition transition);
 
   // Forget all Opener relationships that are stored (but _not_ group
   // relationships!) This is to reduce unpredictable tab switching behavior
@@ skipping 228 matching lines @@
 
   // Implementation of MoveSelectedTabsTo. Moves |length| of the selected tabs
   // starting at |start| to |index|. See MoveSelectedTabsTo for more details.
   void MoveSelectedTabsToImpl(int index, size_t start, size_t length);
 
   // 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.
   struct TabContentsData;
   static bool OpenerMatches(const TabContentsData* data,
-                            const NavigationController* opener,
+                            const content::NavigationController* opener,
                             bool use_group);
 
   // Sets the group/opener of any tabs that reference |tab| to NULL.
-  void ForgetOpenersAndGroupsReferencing(const NavigationController* tab);
+  void ForgetOpenersAndGroupsReferencing(
+      const content::NavigationController* tab);
 
   // 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(TabContentsWrapper* a_contents)
         : contents(a_contents),
           reset_group_on_select(false),
           pinned(false),
           blocked(false),
           discarded(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) {
+    void SetGroup(content::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;
     }
 
     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.
-    NavigationController* group;
+    content::NavigationController* group;
     // The owner models the same relationship as group, except it is more
     // easily discarded, e.g. when the user switches to a tab not part of the
     // same group. This property is used to determine what tab to select next
     // when one is closed.
-    NavigationController* opener;
+    content::NavigationController* opener;
     // True if our group should be reset the moment selection moves away from
     // this Tab. This is the case for tabs opened in the foreground at the end
     // of the TabStrip while viewing another Tab. If these tabs are closed
     // before selection moves elsewhere, their opener is selected. But if
     // 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;
@@ skipping 25 matching lines @@
 
   // A scoped container for notification registries.
   content::NotificationRegistrar registrar_;
 
   TabStripSelectionModel selection_model_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TabStripModel);
 };
 
 #endif  // CHROME_BROWSER_TABS_TAB_STRIP_MODEL_H_