TabContentsWrapper -> TabContents, part 3.

chrome/browser/ui/browser.h

 // Copyright (c) 2012 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_UI_BROWSER_H_
 #define CHROME_BROWSER_UI_BROWSER_H_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 371 matching lines @@
 
   // TabStripModel pass-thrus /////////////////////////////////////////////////
 
   TabStripModel* tab_strip_model() const { return tab_strip_model_.get(); }
 
   int tab_count() const;
   int active_index() const;
   int GetIndexOfController(
       const content::NavigationController* controller) const;
 
-  // TODO(dpapad): Rename to GetActiveTabContentsWrapper().
-  TabContentsWrapper* GetSelectedTabContentsWrapper() const;
-  // A convenient version of the above which returns the TCW's WebContents.
-  content::WebContents* GetSelectedWebContents() const;
-  TabContentsWrapper* GetTabContentsWrapperAt(int index) const;
-  // A convenient version of the above which returns the TCW's WebContents.
+  TabContents* GetSelectedTabContentsWrapper() const;  // DEPRECATED
+  TabContents* GetActiveTabContents() const;
+  // A convenient version of the above which returns the TabContents's
+  // WebContents.
+  content::WebContents* GetSelectedWebContents() const;  // DEPRECATED
+  content::WebContents* GetActiveWebContents() const;
+  TabContents* GetTabContentsWrapperAt(int index) const;  // DEPRECATED
+  TabContents* GetTabContentsAt(int index) const;
+  // A convenient version of the above which returns the TabContents's
+  // WebContents.
   content::WebContents* GetWebContentsAt(int index) const;
   void ActivateTabAt(int index, bool user_gesture);
   bool IsTabPinned(int index) const;
   bool IsTabDiscarded(int index) const;
   void CloseAllTabs();
 
   // Tab adding/showing functions /////////////////////////////////////////////
 
   // Returns true if the tab strip is editable (for extensions).
   bool IsTabStripEditable() const;
 
   // Returns the index to insert a tab at during session restore and startup.
   // |relative_index| gives the index of the url into the number of tabs that
   // are going to be opened. For example, if three urls are passed in on the
   // command line this is invoked three times with the values 0, 1 and 2.
   int GetIndexForInsertionDuringRestore(int relative_index);
 
   // Adds a selected tab with the specified URL and transition, returns the
-  // created TabContentsWrapper.
-  TabContentsWrapper* AddSelectedTabWithURL(
-      const GURL& url,
-      content::PageTransition transition);
+  // created TabContents.
+  TabContents* AddSelectedTabWithURL(const GURL& url,
+                                     content::PageTransition transition);
 
-  // Add a new tab, given a TabContentsWrapper. A WebContents appropriate to
+  // Add a new tab, given a TabContents. A WebContents appropriate to
   // display the last committed entry is created and returned.
-  content::WebContents* AddTab(TabContentsWrapper* tab_contents,
+  content::WebContents* AddTab(TabContents* tab_contents,
                                content::PageTransition type);
 
   // Add a tab with its session history restored from the SessionRestore
   // system. If select is true, the tab is selected. |tab_index| gives the index
   // to insert the tab at. |selected_navigation| is the index of the
   // TabNavigation in |navigations| to select. If |extension_app_id| is
   // non-empty the tab is an app tab and |extension_app_id| is the id of the
   // extension. If |pin| is true and |tab_index|/ is the last pinned tab, then
   // the newly created tab is pinned. If |from_last_session| is true,
   // |navigations| are from the previous session.
@@ skipping 263 matching lines @@
   void SetBlockCommandExecution(bool block);
 
   // Gets the last blocked command after calling SetBlockCommandExecution(true).
   // Returns the command id or -1 if there is no command blocked. The
   // disposition type of the command will be stored in |*disposition| if it's
   // not null.
   int GetLastBlockedCommand(WindowOpenDisposition* disposition);
 
   // Called by browser::Navigate() when a navigation has occurred in a tab in
   // this Browser. Updates the UI for the start of this navigation.
-  void UpdateUIForNavigationInTab(TabContentsWrapper* contents,
+  void UpdateUIForNavigationInTab(TabContents* contents,
                                   content::PageTransition transition,
                                   bool user_initiated);
 
-  // Shows the cookies collected in the tab contents wrapper.
-  void ShowCollectedCookiesDialog(TabContentsWrapper* wrapper);
+  // Shows the cookies collected in the tab contents.
+  void ShowCollectedCookiesDialog(TabContents* tab_contents);
 
   // Interface implementations ////////////////////////////////////////////////
 
   // Overridden from content::PageNavigator:
   virtual content::WebContents* OpenURL(
       const content::OpenURLParams& params) OVERRIDE;
 
   // Overridden from CommandUpdater::CommandUpdaterDelegate:
   virtual void ExecuteCommandWithDisposition(
       int id,
       WindowOpenDisposition disposition) OVERRIDE;
 
   // Overridden from TabRestoreServiceObserver:
   virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE;
   virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE;
 
-  // Centralized method for creating a TabContentsWrapper, configuring and
+  // Centralized method for creating a TabContents, configuring and
   // installing all its supporting objects and observers.
-  static TabContentsWrapper* TabContentsFactory(
+  static TabContents* TabContentsFactory(
       Profile* profile,
       content::SiteInstance* site_instance,
       int routing_id,
       const content::WebContents* base_web_contents,
       content::SessionStorageNamespace* session_storage_namespace);
 
   // Overridden from TabStripModelDelegate:
-  virtual TabContentsWrapper* AddBlankTab(bool foreground) OVERRIDE;
-  virtual TabContentsWrapper* AddBlankTabAt(int index,
-                                            bool foreground) OVERRIDE;
+  virtual TabContents* AddBlankTab(bool foreground) OVERRIDE;
+  virtual TabContents* AddBlankTabAt(int index,
+                                     bool foreground) OVERRIDE;
   virtual Browser* CreateNewStripWithContents(
-      TabContentsWrapper* detached_contents,
+      TabContents* detached_contents,
       const gfx::Rect& window_bounds,
       const DockInfo& dock_info,
       bool maximize) OVERRIDE;
   virtual int GetDragActions() const OVERRIDE;
-  // Construct a TabContentsWrapper for a given URL, profile and transition
-  // type. If instance is not null, its process will be used to render the tab.
-  virtual TabContentsWrapper* CreateTabContentsForURL(
+  // Construct a TabContents for a given URL, profile and transition type. If
+  // instance is not null, its process will be used to render the tab.
+  virtual TabContents* CreateTabContentsForURL(
       const GURL& url,
       const content::Referrer& referrer,
       Profile* profile,
       content::PageTransition transition,
       bool defer_load,
       content::SiteInstance* instance) const OVERRIDE;
   virtual bool CanDuplicateContentsAt(int index) OVERRIDE;
   virtual void DuplicateContentsAt(int index) OVERRIDE;
   virtual void CloseFrameAfterDragSession() OVERRIDE;
-  virtual void CreateHistoricalTab(TabContentsWrapper* contents) OVERRIDE;
-  virtual bool RunUnloadListenerBeforeClosing(
-      TabContentsWrapper* contents) OVERRIDE;
+  virtual void CreateHistoricalTab(TabContents* contents) OVERRIDE;
+  virtual bool RunUnloadListenerBeforeClosing(TabContents* contents) OVERRIDE;
   virtual bool CanCloseContents(std::vector<int>* indices) OVERRIDE;
   virtual bool CanBookmarkAllTabs() const OVERRIDE;
   virtual void BookmarkAllTabs() OVERRIDE;
   virtual bool CanCloseTab() const OVERRIDE;
   virtual bool CanRestoreTab() OVERRIDE;
   virtual void RestoreTab() OVERRIDE;
   virtual bool LargeIconsPermitted() const OVERRIDE;
 
   // Overridden from TabStripModelObserver:
-  virtual void TabInsertedAt(TabContentsWrapper* contents,
+  virtual void TabInsertedAt(TabContents* contents,
                              int index,
                              bool foreground) OVERRIDE;
   virtual void TabClosingAt(TabStripModel* tab_strip_model,
-                            TabContentsWrapper* contents,
+                            TabContents* contents,
                             int index) OVERRIDE;
-  virtual void TabDetachedAt(TabContentsWrapper* contents, int index) OVERRIDE;
-  virtual void TabDeactivated(TabContentsWrapper* contents) OVERRIDE;
-  virtual void ActiveTabChanged(TabContentsWrapper* old_contents,
-                                TabContentsWrapper* new_contents,
+  virtual void TabDetachedAt(TabContents* contents, int index) OVERRIDE;
+  virtual void TabDeactivated(TabContents* contents) OVERRIDE;
+  virtual void ActiveTabChanged(TabContents* old_contents,
+                                TabContents* new_contents,
                                 int index,
                                 bool user_gesture) OVERRIDE;
-  virtual void TabMoved(TabContentsWrapper* contents,
+  virtual void TabMoved(TabContents* contents,
                         int from_index,
                         int to_index) OVERRIDE;
   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
-                             TabContentsWrapper* old_contents,
-                             TabContentsWrapper* new_contents,
+                             TabContents* old_contents,
+                             TabContents* new_contents,
                              int index) OVERRIDE;
-  virtual void TabPinnedStateChanged(TabContentsWrapper* contents,
+  virtual void TabPinnedStateChanged(TabContents* contents,
                                      int index) OVERRIDE;
   virtual void TabStripEmpty() OVERRIDE;
 
   // Fullscreen permission infobar callbacks.
   // TODO(koz): Remove this and have callers call FullscreenController directly.
   void OnAcceptFullscreenPermission(const GURL& url,
                                     FullscreenExitBubbleType bubble_type);
   void OnDenyFullscreenPermission(FullscreenExitBubbleType bubble_type);
 
   // Figure out if there are tabs that have beforeunload handlers.
@@ skipping 20 matching lines @@
 
   void set_pending_web_app_action(WebAppAction action) {
     pending_web_app_action_ = action;
   }
 
   ExtensionWindowController* extension_window_controller() const {
     return extension_window_controller_.get();
   }
 
  protected:
-  // Wrapper for the factory method in BrowserWindow. This allows subclasses to
+  // Funnel for the factory method in BrowserWindow. This allows subclasses to
   // set their own window.
   virtual BrowserWindow* CreateBrowserWindow();
 
  private:
   friend class BrowserTest;
   friend class FullscreenControllerTest;
   FRIEND_TEST_ALL_PREFIXES(AppModeTest, EnableAppModeTest);
   FRIEND_TEST_ALL_PREFIXES(BrowserTest, NoTabsInPopups);
   FRIEND_TEST_ALL_PREFIXES(BrowserTest, ConvertTabToAppShortcut);
   FRIEND_TEST_ALL_PREFIXES(BrowserTest, OpenAppWindowLikeNtp);
@@ skipping 154 matching lines @@
                          int active_match_ordinal,
                          bool final_update) OVERRIDE;
 
   virtual void RequestToLockMouse(content::WebContents* tab,
                                   bool user_gesture,
                                   bool last_unlocked_by_target) OVERRIDE;
   virtual void LostMouseLock() OVERRIDE;
 
   // Overridden from CoreTabHelperDelegate:
   // Note that the caller is responsible for deleting |old_tab_contents|.
-  virtual void SwapTabContents(TabContentsWrapper* old_tab_contents,
-                               TabContentsWrapper* new_tab_contents) OVERRIDE;
+  virtual void SwapTabContents(TabContents* old_tab_contents,
+                               TabContents* new_tab_contents) OVERRIDE;
 
   // Overridden from SearchEngineTabHelperDelegate:
   virtual void ConfirmAddSearchProvider(TemplateURL* template_url,
                                         Profile* profile) OVERRIDE;
 
   // Overridden from ConstrainedWindowTabHelperDelegate:
-  virtual void SetTabContentBlocked(TabContentsWrapper* contents,
+  virtual void SetTabContentBlocked(TabContents* contents,
                                     bool blocked) OVERRIDE;
 
   // Overridden from BlockedContentTabHelperDelegate:
-  virtual TabContentsWrapper* GetConstrainingContentsWrapper(
-      TabContentsWrapper* source) OVERRIDE;
+  virtual TabContents* GetConstrainingContentsWrapper(
+      TabContents* source) OVERRIDE;
 
   // Overridden from BookmarkTabHelperDelegate:
-  virtual void URLStarredChanged(TabContentsWrapper* source,
+  virtual void URLStarredChanged(TabContents* source,
                                  bool starred) OVERRIDE;
 
   // Overridden from ZoomObserver:
-  virtual void OnZoomIconChanged(TabContentsWrapper* source,
+  virtual void OnZoomIconChanged(TabContents* source,
                                  ZoomController::ZoomIconState state) OVERRIDE;
-  virtual void OnZoomChanged(TabContentsWrapper* source,
+  virtual void OnZoomChanged(TabContents* source,
                              int zoom_percent,
                              bool can_show_bubble) OVERRIDE;
 
   // Overridden from ExtensionTabHelperDelegate:
-  virtual void OnDidGetApplicationInfo(TabContentsWrapper* source,
+  virtual void OnDidGetApplicationInfo(TabContents* source,
                                        int32 page_id) OVERRIDE;
   virtual void OnInstallApplication(
-      TabContentsWrapper* source,
+      TabContents* source,
       const WebApplicationInfo& app_info) OVERRIDE;
 
   // Overridden from SelectFileDialog::Listener:
   virtual void FileSelected(const FilePath& path,
                             int index,
                             void* params) OVERRIDE;
 
   // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Overridden from ProfileSyncServiceObserver:
   virtual void OnStateChanged() OVERRIDE;
 
   // Overriden from InstantDelegate:
-  virtual void ShowInstant(TabContentsWrapper* preview_contents) OVERRIDE;
+  virtual void ShowInstant(TabContents* preview_contents) OVERRIDE;
   virtual void HideInstant() OVERRIDE;
-  virtual void CommitInstant(TabContentsWrapper* preview_contents) OVERRIDE;
+  virtual void CommitInstant(TabContents* preview_contents) OVERRIDE;
   virtual void SetSuggestedText(const string16& text,
                                 InstantCompleteBehavior behavior) OVERRIDE;
   virtual gfx::Rect GetInstantBounds() OVERRIDE;
   virtual void InstantPreviewFocused() OVERRIDE;
-  virtual TabContentsWrapper* GetInstantHostTabContents() const OVERRIDE;
+  virtual TabContents* GetInstantHostTabContents() const OVERRIDE;
 
   // Command and state updating ///////////////////////////////////////////////
 
   // Returns true if the regular Chrome UI (not the fullscreen one and
   // not the single-tab one) is shown. Used for updating window command states
   // only. Consider using SupportsWindowFeature if you need the mentioned
   // functionality anywhere else.
   bool IsShowingMainUI(bool is_fullscreen);
 
   // Initialize state for all browser commands.
@@ skipping 118 matching lines @@
 
   // In-progress download termination handling /////////////////////////////////
 
   // Called when the window is closing to check if potential in-progress
   // downloads should prevent it from closing.
   // Returns true if the window can close, false otherwise.
   bool CanCloseWithInProgressDownloads();
 
   // Assorted utility functions ///////////////////////////////////////////////
 
-  // Sets the delegate of all the parts of the |TabContentsWrapper| that
+  // Sets the delegate of all the parts of the TabContents that
   // are needed.
-  void SetAsDelegate(TabContentsWrapper* tab, Browser* delegate);
+  void SetAsDelegate(TabContents* tab, Browser* delegate);
 
   // Shows the Find Bar, optionally selecting the next entry that matches the
   // existing search string for that Tab. |forward_direction| controls the
   // search direction.
   void FindInPage(bool find_next, bool forward_direction);
 
   // Closes the frame.
   // TODO(beng): figure out if we need this now that the frame itself closes
   //             after a return to the message loop.
   void CloseFrame();
 
-  void TabDetachedAtImpl(TabContentsWrapper* contents,
-      int index, DetachType type);
+  void TabDetachedAtImpl(TabContents* contents, int index, DetachType type);
 
   // Create a preference dictionary for the provided application name, in the
   // given user profile. This is done only once per application name / per
   // session / per user profile.
   static void RegisterAppPrefs(const std::string& app_name, Profile* profile);
 
   // Shared code between Reload() and ReloadIgnoringCache().
   void ReloadInternal(WindowOpenDisposition disposition, bool ignore_cache);
 
   // Depending on the disposition, return the current tab or a clone of the
@@ skipping 18 matching lines @@
   bool IsClosingPermitted();
 
   // Commits the current instant, returning true on success. This is intended
   // for use from OpenCurrentURL.
   bool OpenInstant(WindowOpenDisposition disposition);
 
   // If this browser should have instant one is created, otherwise does nothing.
   void CreateInstantIfNecessary();
 
   // Opens view-source tab for given tab contents.
-  void ViewSource(TabContentsWrapper* tab);
+  void ViewSource(TabContents* tab);
 
   // Opens view-source tab for any frame within given tab contents.
-  void ViewSource(TabContentsWrapper* tab,
+  void ViewSource(TabContents* tab,
                   const GURL& url,
                   const std::string& content_state);
 
   // Retrieves the content restrictions for the currently selected tab.
   // Returns 0 if no tab selected, which is equivalent to no content
   // restrictions active.
   int GetContentRestrictionsForSelectedTab();
 
   // Resets |bookmark_bar_state_| based on the active tab. Notifies the
   // BrowserWindow if necessary.
@@ skipping 158 matching lines @@
   bool window_has_shown_;
 
   // Currently open color chooser. Non-NULL after OpenColorChooser is called and
   // before DidEndColorChooser is called.
   scoped_ptr<content::ColorChooser> color_chooser_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_