TabContentsWrapper -> TabContents, part 3.

chrome/browser/ui/browser.cc

 // 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.
 
 #include "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 108 matching lines @@
 #include "chrome/browser/ui/global_error_service_factory.h"
 #include "chrome/browser/ui/hung_plugin_tab_helper.h"
 #include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/search_engines/search_engine_tab_helper.h"
 #include "chrome/browser/ui/status_bubble.h"
 #include "chrome/browser/ui/sync/browser_synced_window_delegate.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/dock_info.h"
 #include "chrome/browser/ui/tabs/tab_finder.h"
 #include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/web_applications/web_app_ui.h"
 #include "chrome/browser/ui/webui/feedback_ui.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_page_handler.h"
 #include "chrome/browser/ui/webui/options2/content_settings_handler2.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
@@ skipping 439 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Getters & Setters
 
 FindBarController* Browser::GetFindBarController() {
   if (!find_bar_controller_.get()) {
     FindBar* find_bar = window_->CreateFindBar();
     find_bar_controller_.reset(new FindBarController(find_bar));
     find_bar->SetFindBarController(find_bar_controller_.get());
-    find_bar_controller_->ChangeTabContents(GetSelectedTabContentsWrapper());
+    find_bar_controller_->ChangeTabContents(GetActiveTabContents());
     find_bar_controller_->find_bar()->MoveWindowIfNecessary(gfx::Rect(), true);
   }
   return find_bar_controller_.get();
 }
 
 bool Browser::HasFindBarController() const {
   return find_bar_controller_.get() != NULL;
 }
 
 bool Browser::is_app() const {
@@ skipping 242 matching lines @@
 
   const DictionaryValue* window_pref =
       profile()->GetPrefs()->GetDictionary(GetWindowPlacementKey().c_str());
   bool maximized = false;
   window_pref->GetBoolean("maximized", &maximized);
 
   return maximized ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_DEFAULT;
 }
 
 SkBitmap Browser::GetCurrentPageIcon() const {
-  TabContentsWrapper* contents = GetSelectedTabContentsWrapper();
+  TabContents* contents = GetActiveTabContents();
   // |contents| can be NULL since GetCurrentPageIcon() is called by the window
   // during the window's creation (before tabs have been added).
   return contents ? contents->favicon_tab_helper()->GetFavicon() : SkBitmap();
 }
 
 string16 Browser::GetWindowTitleForCurrentTab() const {
-  WebContents* contents = GetSelectedWebContents();
+  WebContents* contents = GetActiveWebContents();
   string16 title;
 
   // |contents| can be NULL because GetWindowTitleForCurrentTab is called by the
   // window during the window's creation (before tabs have been added).
   if (contents) {
     title = contents->GetTitle();
     FormatTitleForDisplay(&title);
   }
   if (title.empty())
     title = CoreTabHelper::GetDefaultTitle();
@@ skipping 81 matching lines @@
       chrome::NOTIFICATION_BROWSER_CLOSING,
       content::Source<Browser>(this),
       content::Details<bool>(&exiting));
 
   CloseAllTabs();
 }
 
 void Browser::OnWindowActivated() {
   // On some platforms we want to automatically reload tabs that are
   // killed when the user selects them.
-  WebContents* contents = GetSelectedWebContents();
+  WebContents* contents = GetActiveWebContents();
   if (contents && contents->GetCrashedStatus() ==
      base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kReloadKilledTabs)) {
       Reload(CURRENT_TAB);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 82 matching lines @@
 
 int Browser::active_index() const {
   return tab_strip_model_->active_index();
 }
 
 int Browser::GetIndexOfController(
     const NavigationController* controller) const {
   return tab_strip_model_->GetIndexOfController(controller);
 }
 
-TabContentsWrapper* Browser::GetSelectedTabContentsWrapper() const {
+// DEPRECATED
+TabContents* Browser::GetSelectedTabContentsWrapper() const {
+  return GetActiveTabContents();
+}
+
+TabContents* Browser::GetActiveTabContents() const {
   return tab_strip_model_->GetActiveTabContents();
 }
 
+// DEPRECATED
 WebContents* Browser::GetSelectedWebContents() const {
-  TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
-  return wrapper ? wrapper->web_contents() : NULL;
+  return GetActiveWebContents();
 }
 
-TabContentsWrapper* Browser::GetTabContentsWrapperAt(int index) const {
+WebContents* Browser::GetActiveWebContents() const {
+  TabContents* tab_contents = GetActiveTabContents();
+  return tab_contents ? tab_contents->web_contents() : NULL;
+}
+
+// DEPRECATED
+TabContents* Browser::GetTabContentsWrapperAt(int index) const {
+  return GetTabContentsAt(index);
+}
+
+TabContents* Browser::GetTabContentsAt(int index) const {
   return tab_strip_model_->GetTabContentsAt(index);
 }
 
 WebContents* Browser::GetWebContentsAt(int index) const {
-  TabContentsWrapper* wrapper = GetTabContentsWrapperAt(index);
-  if (wrapper)
-    return wrapper->web_contents();
+  TabContents* tab_contents = GetTabContentsAt(index);
+  if (tab_contents)
+    return tab_contents->web_contents();
   return NULL;
 }
 
 void Browser::ActivateTabAt(int index, bool user_gesture) {
   tab_strip_model_->ActivateTabAt(index, user_gesture);
 }
 
 bool Browser::IsTabPinned(int index) const {
   return tab_strip_model_->IsTabPinned(index);
 }
@@ skipping 11 matching lines @@
 
 bool Browser::IsTabStripEditable() const {
   return window()->IsTabStripEditable();
 }
 
 int Browser::GetIndexForInsertionDuringRestore(int relative_index) {
   return (tab_strip_model_->insertion_policy() == TabStripModel::INSERT_AFTER) ?
       tab_count() : relative_index;
 }
 
-TabContentsWrapper* Browser::AddSelectedTabWithURL(
+TabContents* Browser::AddSelectedTabWithURL(
     const GURL& url,
     content::PageTransition transition) {
   browser::NavigateParams params(this, url, transition);
   params.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&params);
   return params.target_contents;
 }
 
-WebContents* Browser::AddTab(TabContentsWrapper* tab_contents,
+WebContents* Browser::AddTab(TabContents* tab_contents,
                              content::PageTransition type) {
   tab_strip_model_->AddTabContents(tab_contents, -1, type,
                                    TabStripModel::ADD_ACTIVE);
   return tab_contents->web_contents();
 }
 
 WebContents* Browser::AddRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int tab_index,
     int selected_navigation,
     const std::string& extension_app_id,
     bool select,
     bool pin,
     bool from_last_session,
     content::SessionStorageNamespace* session_storage_namespace) {
   GURL restore_url = navigations.at(selected_navigation).virtual_url();
-  TabContentsWrapper* wrapper = TabContentsFactory(
+  TabContents* tab_contents = TabContentsFactory(
       profile(),
       tab_util::GetSiteInstanceForNewTab(profile_, restore_url),
       MSG_ROUTING_NONE,
-      GetSelectedWebContents(),
+      GetActiveWebContents(),
       session_storage_namespace);
-  WebContents* new_tab = wrapper->web_contents();
-  wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
+  WebContents* new_tab = tab_contents->web_contents();
+  tab_contents->extension_tab_helper()->SetExtensionAppById(extension_app_id);
   std::vector<NavigationEntry*> entries;
   TabNavigation::CreateNavigationEntriesFromTabNavigations(
       profile_, navigations, &entries);
   new_tab->GetController().Restore(
       selected_navigation, from_last_session, &entries);
   DCHECK_EQ(0u, entries.size());
 
   int add_types = select ? TabStripModel::ADD_ACTIVE :
       TabStripModel::ADD_NONE;
   if (pin) {
     int first_mini_tab_idx = tab_strip_model_->IndexOfFirstNonMiniTab();
     tab_index = std::min(tab_index, first_mini_tab_idx);
     add_types |= TabStripModel::ADD_PINNED;
   }
-  tab_strip_model_->InsertTabContentsAt(tab_index, wrapper, add_types);
+  tab_strip_model_->InsertTabContentsAt(tab_index, tab_contents, add_types);
   if (select) {
     window_->Activate();
   } else {
     // We set the size of the view here, before WebKit does its initial
     // layout.  If we don't, the initial layout of background tabs will be
     // performed with a view width of 0, which may cause script outputs and
     // anchor link location calculations to be incorrect even after a new
     // layout with proper view dimensions. TabStripModel::AddTabContents()
     // contains similar logic.
     new_tab->GetView()->SizeContents(window_->GetRestoredBounds().size());
     new_tab->HideContents();
   }
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
-    session_service->TabRestored(wrapper, pin);
+    session_service->TabRestored(tab_contents, pin);
   return new_tab;
 }
 
 void Browser::AddWebContents(WebContents* new_contents,
                              WindowOpenDisposition disposition,
                              const gfx::Rect& initial_pos,
                              bool user_gesture) {
   AddNewContents(NULL, new_contents, disposition, initial_pos, user_gesture);
 }
 
@@ skipping 18 matching lines @@
   window_->ToolbarSizeChanged(is_animating);
 }
 
 void Browser::ReplaceRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int selected_navigation,
     bool from_last_session,
     const std::string& extension_app_id,
     content::SessionStorageNamespace* session_storage_namespace) {
   GURL restore_url = navigations.at(selected_navigation).virtual_url();
-  TabContentsWrapper* wrapper = TabContentsFactory(
+  TabContents* tab_contents = TabContentsFactory(
       profile(),
       tab_util::GetSiteInstanceForNewTab(profile_, restore_url),
       MSG_ROUTING_NONE,
-      GetSelectedWebContents(),
+      GetActiveWebContents(),
       session_storage_namespace);
-  wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
-  WebContents* replacement = wrapper->web_contents();
+  tab_contents->extension_tab_helper()->SetExtensionAppById(extension_app_id);
+  WebContents* replacement = tab_contents->web_contents();
   std::vector<NavigationEntry*> entries;
   TabNavigation::CreateNavigationEntriesFromTabNavigations(
       profile_, navigations, &entries);
   replacement->GetController().Restore(
       selected_navigation, from_last_session, &entries);
   DCHECK_EQ(0u, entries.size());
 
-  tab_strip_model_->ReplaceNavigationControllerAt(active_index(), wrapper);
+  tab_strip_model_->ReplaceNavigationControllerAt(active_index(), tab_contents);
 }
 
 bool Browser::NavigateToIndexWithDisposition(int index,
                                              WindowOpenDisposition disp) {
   NavigationController& controller =
       GetOrCloneTabForDisposition(disp)->GetController();
   if (index < 0 || index >= controller.GetEntryCount())
     return false;
   controller.GoToIndex(index);
   return true;
 }
 
 void Browser::ShowSingletonTab(const GURL& url) {
   browser::NavigateParams params(GetSingletonTabNavigateParams(url));
   browser::Navigate(&params);
 }
 
 void Browser::ShowSingletonTabRespectRef(const GURL& url) {
   browser::NavigateParams params(GetSingletonTabNavigateParams(url));
   params.ref_behavior = browser::NavigateParams::RESPECT_REF;
   browser::Navigate(&params);
 }
 
 void Browser::ShowSingletonTabOverwritingNTP(
     const browser::NavigateParams& params) {
   browser::NavigateParams local_params(params);
-  WebContents* contents = GetSelectedWebContents();
+  WebContents* contents = GetActiveWebContents();
   if (contents) {
     const GURL& contents_url = contents->GetURL();
     if ((contents_url == GURL(chrome::kChromeUINewTabURL) ||
          contents_url == GURL(chrome::kAboutBlankURL)) &&
         browser::GetIndexOfSingletonTab(&local_params) < 0) {
       local_params.disposition = CURRENT_TAB;
     }
   }
 
   browser::Navigate(&local_params);
@@ skipping 12 matching lines @@
 void Browser::WindowFullscreenStateChanged() {
   fullscreen_controller_->WindowFullscreenStateChanged();
   UpdateCommandsForFullscreenMode(window_->IsFullscreen());
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TOGGLE_FULLSCREEN);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Assorted browser commands:
 
 bool Browser::CanGoBack() const {
-  return GetSelectedWebContents()->GetController().CanGoBack();
+  return GetActiveWebContents()->GetController().CanGoBack();
 }
 
 void Browser::GoBack(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Back"));
 
-  TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
+  TabContents* current_tab = GetActiveTabContents();
   if (CanGoBack()) {
     WebContents* new_tab = GetOrCloneTabForDisposition(disposition);
     // If we are on an interstitial page and clone the tab, it won't be copied
     // to the new tab, so we don't need to go back.
     if (current_tab->web_contents()->ShowingInterstitialPage() &&
         (new_tab != current_tab->web_contents()))
       return;
     new_tab->GetController().GoBack();
   }
 }
 
 bool Browser::CanGoForward() const {
-  return GetSelectedWebContents()->GetController().CanGoForward();
+  return GetActiveWebContents()->GetController().CanGoForward();
 }
 
 void Browser::GoForward(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward())
     GetOrCloneTabForDisposition(disposition)->GetController().GoForward();
 }
 
 void Browser::Reload(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Reload"));
@@ skipping 50 matching lines @@
 
   DCHECK(profile_->GetExtensionService());
   if (profile_->GetExtensionService()->IsInstalledApp(url)) {
     AppLauncherHandler::RecordAppLaunchType(
         extension_misc::APP_LAUNCH_OMNIBOX_LOCATION);
   }
 }
 
 void Browser::Stop() {
   content::RecordAction(UserMetricsAction("Stop"));
-  GetSelectedWebContents()->Stop();
+  GetActiveWebContents()->Stop();
 }
 
 #if !defined(OS_WIN)
 void Browser::NewWindow() {
   NewEmptyWindow(profile_->GetOriginalProfile());
 }
 
 void Browser::NewIncognitoWindow() {
   NewEmptyWindow(profile_->GetOffTheRecordProfile());
 }
 #endif  // OS_WIN
 
 void Browser::CloseWindow() {
   content::RecordAction(UserMetricsAction("CloseWindow"));
   window_->Close();
 }
 
 void Browser::NewTab() {
   content::RecordAction(UserMetricsAction("NewTab"));
 
   if (is_type_tabbed()) {
     AddBlankTab(true);
-    GetSelectedWebContents()->GetView()->RestoreFocus();
+    GetActiveWebContents()->GetView()->RestoreFocus();
   } else {
     Browser* b = browser::FindOrCreateTabbedBrowser(profile_);
     b->AddBlankTab(true);
     b->window()->Show();
     // The call to AddBlankTab above did not set the focus to the tab as its
     // window was not active, so we have to do it explicitly.
     // See http://crbug.com/6380.
-    b->GetSelectedWebContents()->GetView()->RestoreFocus();
+    b->GetActiveWebContents()->GetView()->RestoreFocus();
   }
 }
 
 void Browser::CloseTab() {
   content::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   if (CanCloseTab())
     tab_strip_model_->CloseSelectedTabs();
 }
 
 void Browser::SelectNextTab() {
@@ skipping 45 matching lines @@
 void Browser::DuplicateTab() {
   content::RecordAction(UserMetricsAction("Duplicate"));
   DuplicateContentsAt(active_index());
 }
 
 void Browser::WriteCurrentURLToClipboard() {
   // TODO(ericu): There isn't currently a metric for this.  Should there be?
   // We don't appear to track the action when it comes from the
   // RenderContextViewMenu.
 
-  WebContents* contents = GetSelectedWebContents();
+  WebContents* contents = GetActiveWebContents();
   if (!toolbar_model_->ShouldDisplayURL())
     return;
 
   chrome_common_net::WriteURLToClipboard(
       contents->GetURL(),
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void Browser::ConvertPopupToTabbedBrowser() {
   content::RecordAction(UserMetricsAction("ShowAsTab"));
-  TabContentsWrapper* contents = tab_strip_model_->DetachTabContentsAt(
-      active_index());
+  TabContents* contents = tab_strip_model_->DetachTabContentsAt(active_index());
   Browser* browser = Browser::Create(profile_);
   browser->tab_strip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 void Browser::ToggleFullscreenMode() {
   fullscreen_controller_->ToggleFullscreenMode();
 }
 
 void Browser::ToggleFullscreenModeWithExtension(const GURL& extension_url) {
@@ skipping 13 matching lines @@
 
 void Browser::BookmarkCurrentPage() {
   content::RecordAction(UserMetricsAction("Star"));
 
   BookmarkModel* model = profile()->GetBookmarkModel();
   if (!model || !model->IsLoaded())
     return;  // Ignore requests until bookmarks are loaded.
 
   GURL url;
   string16 title;
-  TabContentsWrapper* tab = GetSelectedTabContentsWrapper();
+  TabContents* tab = GetActiveTabContents();
   bookmark_utils::GetURLAndTitleToBookmark(tab->web_contents(), &url, &title);
   bool was_bookmarked = model->IsBookmarked(url);
   if (!was_bookmarked && profile_->IsOffTheRecord()) {
     // If we're incognito the favicon may not have been saved. Save it now
     // so that bookmarks have an icon for the page.
     tab->favicon_tab_helper()->SaveFavicon();
   }
   bookmark_utils::AddIfNotBookmarked(model, url, title);
   // Make sure the model actually added a bookmark before showing the star. A
   // bookmark isn't created if the url is invalid.
   if (window_->IsActive() && model->IsBookmarked(url)) {
     // Only show the bubble if the window is active, otherwise we may get into
     // weird situations where the bubble is deleted as soon as it is shown.
     window_->ShowBookmarkBubble(url, was_bookmarked);
   }
 }
 
 void Browser::SavePage() {
   content::RecordAction(UserMetricsAction("SavePage"));
-  WebContents* current_tab = GetSelectedWebContents();
+  WebContents* current_tab = GetActiveWebContents();
   if (current_tab && current_tab->GetContentsMimeType() == "application/pdf")
     content::RecordAction(UserMetricsAction("PDF.SavePage"));
-  GetSelectedWebContents()->OnSavePage();
+  GetActiveWebContents()->OnSavePage();
 }
 
 void Browser::ViewSelectedSource() {
-  ViewSource(GetSelectedTabContentsWrapper());
+  ViewSource(GetActiveTabContents());
 }
 
 void Browser::ShowFindBar() {
   GetFindBarController()->Show();
 }
 
 void Browser::ShowPageInfo(content::WebContents* web_contents,
                            const GURL& url,
                            const SSLStatus& ssl,
                            bool show_history) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents->GetBrowserContext());
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
+  TabContents* tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(web_contents);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableWebsiteSettings)) {
-    window()->ShowWebsiteSettings(profile, wrapper, url, ssl, show_history);
+    window()->ShowWebsiteSettings(
+        profile, tab_contents, url, ssl, show_history);
   } else {
     window()->ShowPageInfo(profile, url, ssl, show_history);
   }
 }
 
 void Browser::ShowChromeToMobileBubble() {
   // Only show the bubble if the window is active, otherwise we may get into
   // weird situations where the bubble is deleted as soon as it is shown.
   if (window_->IsActive())
     window_->ShowChromeToMobileBubble();
 }
 
 bool Browser::SupportsWindowFeature(WindowFeature feature) const {
   return SupportsWindowFeatureImpl(feature, true);
 }
 
 bool Browser::CanSupportWindowFeature(WindowFeature feature) const {
   return SupportsWindowFeatureImpl(feature, false);
 }
 
 void Browser::Print() {
   if (g_browser_process->local_state()->GetBoolean(
           prefs::kPrintPreviewDisabled)) {
-    GetSelectedTabContentsWrapper()->print_view_manager()->PrintNow();
+    GetActiveTabContents()->print_view_manager()->PrintNow();
   } else {
-    GetSelectedTabContentsWrapper()->print_view_manager()->PrintPreviewNow();
+    GetActiveTabContents()->print_view_manager()->PrintPreviewNow();
   }
 }
 
 void Browser::AdvancedPrint() {
-  GetSelectedTabContentsWrapper()->print_view_manager()->AdvancedPrintNow();
+  GetActiveTabContents()->print_view_manager()->AdvancedPrintNow();
 }
 
 void Browser::EmailPageLocation() {
   content::RecordAction(UserMetricsAction("EmailPageLocation"));
-  WebContents* wc = GetSelectedWebContents();
+  WebContents* wc = GetActiveWebContents();
   DCHECK(wc);
 
   std::string title = net::EscapeQueryParamValue(
       UTF16ToUTF8(wc->GetTitle()), false);
   std::string page_url = net::EscapeQueryParamValue(wc->GetURL().spec(), false);
   std::string mailto = std::string("mailto:?subject=Fwd:%20") +
       title + "&body=%0A%0A" + page_url;
   platform_util::OpenExternal(GURL(mailto));
 }
 
 void Browser::ToggleEncodingAutoDetect() {
   content::RecordAction(UserMetricsAction("AutoDetectChange"));
   encoding_auto_detect_.SetValue(!encoding_auto_detect_.GetValue());
   // If "auto detect" is turned on, then any current override encoding
   // is cleared. This also implicitly performs a reload.
   // OTOH, if "auto detect" is turned off, we don't change the currently
   // active encoding.
   if (encoding_auto_detect_.GetValue()) {
-    WebContents* contents = GetSelectedWebContents();
+    WebContents* contents = GetActiveWebContents();
     if (contents)
       contents->ResetOverrideEncoding();
   }
 }
 
 void Browser::OverrideEncoding(int encoding_id) {
   content::RecordAction(UserMetricsAction("OverrideEncoding"));
   const std::string selected_encoding =
       CharacterEncoding::GetCanonicalEncodingNameByCommandId(encoding_id);
-  WebContents* contents = GetSelectedWebContents();
+  WebContents* contents = GetActiveWebContents();
   if (!selected_encoding.empty() && contents)
      contents->SetOverrideEncoding(selected_encoding);
   // Update the list of recently selected encodings.
   std::string new_selected_encoding_list;
   if (CharacterEncoding::UpdateRecentlySelectedEncoding(
         profile_->GetPrefs()->GetString(prefs::kRecentlySelectedEncoding),
         encoding_id,
         &new_selected_encoding_list)) {
     profile_->GetPrefs()->SetString(prefs::kRecentlySelectedEncoding,
                                     new_selected_encoding_list);
@@ skipping 27 matching lines @@
 
 void Browser::FindPrevious() {
   content::RecordAction(UserMetricsAction("FindPrevious"));
   FindInPage(true, false);
 }
 
 void Browser::Zoom(content::PageZoom zoom) {
   if (is_devtools())
     return;
 
-  content::RenderViewHost* host = GetSelectedWebContents()->GetRenderViewHost();
+  content::RenderViewHost* host = GetActiveWebContents()->GetRenderViewHost();
   if (zoom == content::PAGE_ZOOM_RESET) {
     host->SetZoomLevel(0);
     content::RecordAction(UserMetricsAction("ZoomNormal"));
     return;
   }
 
-  double current_zoom_level = GetSelectedWebContents()->GetZoomLevel();
+  double current_zoom_level = GetActiveWebContents()->GetZoomLevel();
   double default_zoom_level =
       profile_->GetPrefs()->GetDouble(prefs::kDefaultZoomLevel);
 
   // Generate a vector of zoom levels from an array of known presets along with
   // the default level added if necessary.
   std::vector<double> zoom_levels =
       chrome_page_zoom::PresetZoomLevels(default_zoom_level);
 
   if (zoom == content::PAGE_ZOOM_OUT) {
     // Iterate through the zoom levels in reverse order to find the next
@@ skipping 69 matching lines @@
   if (!select_file_dialog_.get())
     select_file_dialog_ = SelectFileDialog::Create(this);
 
   const FilePath directory = profile_->last_selected_directory();
 
   // TODO(beng): figure out how to juggle this.
   gfx::NativeWindow parent_window = window_->GetNativeHandle();
   select_file_dialog_->SelectFile(SelectFileDialog::SELECT_OPEN_FILE,
                                   string16(), directory,
                                   NULL, 0, FILE_PATH_LITERAL(""),
-                                  GetSelectedWebContents(),
+                                  GetActiveWebContents(),
                                   parent_window, NULL);
 }
 
 void Browser::OpenCreateShortcutsDialog() {
   content::RecordAction(UserMetricsAction("CreateShortcut"));
 #if !defined(OS_MACOSX)
-  TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
+  TabContents* current_tab = GetActiveTabContents();
   DCHECK(current_tab &&
       web_app::IsValidUrl(current_tab->web_contents()->GetURL())) <<
           "Menu item should be disabled.";
 
   NavigationEntry* entry =
       current_tab->web_contents()->GetController().GetLastCommittedEntry();
   if (!entry)
     return;
 
   // RVH's GetApplicationInfo should not be called before it returns.
   DCHECK(pending_web_app_action_ == NONE);
   pending_web_app_action_ = CREATE_SHORTCUT;
 
   // Start fetching web app info for CreateApplicationShortcut dialog and show
   // the dialog when the data is available in OnDidGetApplicationInfo.
   current_tab->extension_tab_helper()->GetApplicationInfo(entry->GetPageID());
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 void Browser::ToggleDevToolsWindow(DevToolsToggleAction action) {
   if (action == DEVTOOLS_TOGGLE_ACTION_SHOW_CONSOLE)
     content::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
   else
     content::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
 
   DevToolsWindow::ToggleDevToolsWindow(
-      GetSelectedWebContents()->GetRenderViewHost(),
+      GetActiveWebContents()->GetRenderViewHost(),
       action);
 }
 
 void Browser::OpenTaskManager(bool highlight_background_resources) {
   content::RecordAction(UserMetricsAction("TaskManager"));
   if (highlight_background_resources)
     window_->ShowBackgroundPages();
   else
     window_->ShowTaskManager();
 }
@@ skipping 182 matching lines @@
     browser::NavigateParams params(GetSingletonTabNavigateParams(GURL(url)));
     params.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
     ShowSingletonTabOverwritingNTP(params);
   } else {
     LoginUIServiceFactory::GetForProfile(
         profile()->GetOriginalProfile())->ShowLoginUI();
   }
 }
 
 void Browser::ToggleSpeechInput() {
-  GetSelectedWebContents()->GetRenderViewHost()->ToggleSpeechInput();
+  GetActiveWebContents()->GetRenderViewHost()->ToggleSpeechInput();
 }
 
 void Browser::UpdateDownloadShelfVisibility(bool visible) {
   if (GetStatusBubble())
     GetStatusBubble()->UpdateDownloadShelfVisibility(visible);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // static
@@ skipping 182 matching lines @@
     // to proceed closing the page or not, which sends us back to this method
     // with the NeedToFireBeforeUnload bit cleared.
     contents->GetRenderViewHost()->FirePageBeforeUnload(false);
     return true;
   }
   return false;
 }
 
 // static
 void Browser::JSOutOfMemoryHelper(WebContents* tab) {
-  TabContentsWrapper* tcw = TabContentsWrapper::GetCurrentWrapperForContents(
+  TabContents* tab_contents = TabContents::GetOwningTabContentsForWebContents(
       tab);
-  if (!tcw)
+  if (!tab_contents)
     return;
 
-  InfoBarTabHelper* infobar_helper = tcw->infobar_tab_helper();
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   infobar_helper->AddInfoBar(new SimpleAlertInfoBarDelegate(
       infobar_helper,
       NULL,
       l10n_util::GetStringUTF16(IDS_JS_OUT_OF_MEMORY_PROMPT),
       true));
 }
 
 // static
 void Browser::RegisterProtocolHandlerHelper(WebContents* tab,
                                             const std::string& protocol,
                                             const GURL& url,
                                             const string16& title,
                                             bool user_gesture) {
-  TabContentsWrapper* tcw = TabContentsWrapper::GetCurrentWrapperForContents(
+  TabContents* tab_contents = TabContents::GetOwningTabContentsForWebContents(
       tab);
-  if (!tcw || tcw->profile()->IsOffTheRecord())
+  if (!tab_contents || tab_contents->profile()->IsOffTheRecord())
     return;
 
   ProtocolHandler handler =
       ProtocolHandler::CreateProtocolHandler(protocol, url, title);
 
   ProtocolHandlerRegistry* registry =
-      tcw->profile()->GetProtocolHandlerRegistry();
+      tab_contents->profile()->GetProtocolHandlerRegistry();
 
   if (!registry->SilentlyHandleRegisterHandlerRequest(handler)) {
     content::RecordAction(
         UserMetricsAction("RegisterProtocolHandler.InfoBar_Shown"));
-    InfoBarTabHelper* infobar_helper = tcw->infobar_tab_helper();
+    InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
 
     RegisterProtocolHandlerInfoBarDelegate* rph_delegate =
         new RegisterProtocolHandlerInfoBarDelegate(infobar_helper,
                                                    registry,
                                                    handler);
 
     for (size_t i = 0; i < infobar_helper->infobar_count(); i++) {
       InfoBarDelegate* delegate = infobar_helper->GetInfoBarDelegateAt(i);
       RegisterProtocolHandlerInfoBarDelegate* cast_delegate =
           delegate->AsRegisterProtocolHandlerInfoBarDelegate();
       if (cast_delegate != NULL && cast_delegate->IsReplacedBy(rph_delegate)) {
         infobar_helper->ReplaceInfoBar(cast_delegate, rph_delegate);
         rph_delegate = NULL;
         break;
       }
     }
 
     if (rph_delegate != NULL)
       infobar_helper->AddInfoBar(rph_delegate);
   }
 }
 
 // static
 void Browser::FindReplyHelper(WebContents* tab,
                               int request_id,
                               int number_of_matches,
                               const gfx::Rect& selection_rect,
                               int active_match_ordinal,
                               bool final_update) {
-  TabContentsWrapper* tcw = TabContentsWrapper::GetCurrentWrapperForContents(
+  TabContents* tab_contents = TabContents::GetOwningTabContentsForWebContents(
       tab);
-  if (!tcw || !tcw->find_tab_helper())
+  if (!tab_contents || !tab_contents->find_tab_helper())
     return;
 
-  tcw->find_tab_helper()->HandleFindReply(request_id, number_of_matches,
-                                          selection_rect, active_match_ordinal,
-                                          final_update);
+  tab_contents->find_tab_helper()->HandleFindReply(request_id,
+                                                   number_of_matches,
+                                                   selection_rect,
+                                                   active_match_ordinal,
+                                                   final_update);
 }
 
 void Browser::ExecuteCommand(int id) {
   ExecuteCommandWithDisposition(id, CURRENT_TAB);
 }
 
 void Browser::ExecuteCommand(int id, int event_flags) {
   ExecuteCommandWithDisposition(
       id, browser::DispositionFromEventFlags(event_flags));
 }
@@ skipping 52 matching lines @@
     last_blocked_command_disposition_ = CURRENT_TAB;
   }
 }
 
 int Browser::GetLastBlockedCommand(WindowOpenDisposition* disposition) {
   if (disposition)
     *disposition = last_blocked_command_disposition_;
   return last_blocked_command_id_;
 }
 
-void Browser::UpdateUIForNavigationInTab(TabContentsWrapper* contents,
+void Browser::UpdateUIForNavigationInTab(TabContents* contents,
                                          content::PageTransition transition,
                                          bool user_initiated) {
   tab_strip_model_->TabNavigating(contents, transition);
 
-  bool contents_is_selected = contents == GetSelectedTabContentsWrapper();
+  bool contents_is_selected = contents == GetActiveTabContents();
   if (user_initiated && contents_is_selected && window()->GetLocationBar()) {
     // Forcibly reset the location bar if the url is going to change in the
     // current tab, since otherwise it won't discard any ongoing user edits,
     // since it doesn't realize this is a user-initiated action.
     window()->GetLocationBar()->Revert();
   }
 
   if (GetStatusBubble())
     GetStatusBubble()->Hide();
 
   // Update the location bar. This is synchronous. We specifically don't
   // update the load state since the load hasn't started yet and updating it
   // will put it out of sync with the actual state like whether we're
   // displaying a favicon, which controls the throbber. If we updated it here,
   // the throbber will show the default favicon for a split second when
   // navigating away from the new tab page.
   ScheduleUIUpdate(contents->web_contents(), content::INVALIDATE_TYPE_URL);
 
   if (contents_is_selected)
     contents->web_contents()->Focus();
 }
 
-void Browser::ShowCollectedCookiesDialog(TabContentsWrapper* wrapper) {
-  browser::ShowCollectedCookiesDialog(window()->GetNativeHandle(), wrapper);
+void Browser::ShowCollectedCookiesDialog(TabContents* tab_contents) {
+  browser::ShowCollectedCookiesDialog(window()->GetNativeHandle(),
+                                      tab_contents);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, PageNavigator implementation:
 
 WebContents* Browser::OpenURL(const OpenURLParams& params) {
   return OpenURLFromTab(NULL, params);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CommandUpdater::CommandUpdaterDelegate implementation:
 
 void Browser::ExecuteCommandWithDisposition(
   int id, WindowOpenDisposition disposition) {
   // No commands are enabled if there is not yet any selected tab.
   // TODO(pkasting): It seems like we should not need this, because either
   // most/all commands should not have been enabled yet anyway or the ones that
   // are enabled should be global, or safe themselves against having no selected
   // tab.  However, Ben says he tried removing this before and got lots of
   // crashes, e.g. from Windows sending WM_COMMANDs at random times during
   // window construction.  This probably could use closer examination someday.
-  if (!GetSelectedTabContentsWrapper())
+  if (!GetActiveTabContents())
     return;
 
   DCHECK(command_updater_.IsCommandEnabled(id)) << "Invalid/disabled command "
                                                 << id;
 
   // If command execution is blocked then just record the command and return.
   if (block_command_execution_) {
     // We actually only allow no more than one blocked command, otherwise some
     // commands maybe lost.
     DCHECK_EQ(last_blocked_command_id_, -1);
@@ skipping 171 matching lines @@
 
 void Browser::TabRestoreServiceDestroyed(TabRestoreService* service) {
   if (!tab_restore_service_)
     return;
 
   DCHECK_EQ(tab_restore_service_, service);
   tab_restore_service_->RemoveObserver(this);
   tab_restore_service_ = NULL;
 }
 
-// Centralized method for creating a TabContentsWrapper, configuring and
+// Centralized method for creating a TabContents, configuring and
 // installing all its supporting objects and observers.
-TabContentsWrapper* Browser::TabContentsFactory(
+TabContents* Browser::TabContentsFactory(
     Profile* profile,
     SiteInstance* site_instance,
     int routing_id,
     const WebContents* base_web_contents,
     content::SessionStorageNamespace* session_storage_namespace) {
   WebContents* new_contents = WebContents::Create(
       profile, site_instance, routing_id, base_web_contents,
       session_storage_namespace);
-  TabContentsWrapper* wrapper = new TabContentsWrapper(new_contents);
-  return wrapper;
+  TabContents* tab_contents = new TabContents(new_contents);
+  return tab_contents;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelDelegate implementation:
 
-TabContentsWrapper* Browser::AddBlankTab(bool foreground) {
+TabContents* Browser::AddBlankTab(bool foreground) {
   return AddBlankTabAt(-1, foreground);
 }
 
-TabContentsWrapper* Browser::AddBlankTabAt(int index, bool foreground) {
+TabContents* Browser::AddBlankTabAt(int index, bool foreground) {
   // Time new tab page creation time.  We keep track of the timing data in
   // WebContents, but we want to include the time it takes to create the
   // WebContents object too.
   base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
   browser::NavigateParams params(this, GURL(chrome::kChromeUINewTabURL),
                                  content::PAGE_TRANSITION_TYPED);
   params.disposition = foreground ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   params.tabstrip_index = index;
   browser::Navigate(&params);
   params.target_contents->web_contents()->SetNewTabStartTime(
       new_tab_start_time);
   return params.target_contents;
 }
 
 Browser* Browser::CreateNewStripWithContents(
-    TabContentsWrapper* detached_contents,
+    TabContents* detached_contents,
     const gfx::Rect& window_bounds,
     const DockInfo& dock_info,
     bool maximize) {
   DCHECK(CanSupportWindowFeature(FEATURE_TABSTRIP));
 
   gfx::Rect new_window_bounds = window_bounds;
   if (dock_info.GetNewWindowBounds(&new_window_bounds, &maximize))
     dock_info.AdjustOtherWindowBounds();
 
   // Create an empty new browser window the same size as the old one.
   Browser* browser = new Browser(TYPE_TABBED, profile_);
   browser->set_override_bounds(new_window_bounds);
   browser->set_show_state(
       maximize ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_NORMAL);
   browser->InitBrowserWindow();
   browser->tab_strip_model()->AppendTabContents(detached_contents, true);
   // Make sure the loading state is updated correctly, otherwise the throbber
   // won't start if the page is loading.
   browser->LoadingStateChanged(detached_contents->web_contents());
   return browser;
 }
 
 int Browser::GetDragActions() const {
   return TabStripModelDelegate::TAB_TEAROFF_ACTION | (tab_count() > 1 ?
       TabStripModelDelegate::TAB_MOVE_ACTION : 0);
 }
 
-TabContentsWrapper* Browser::CreateTabContentsForURL(
+TabContents* Browser::CreateTabContentsForURL(
     const GURL& url, const content::Referrer& referrer, Profile* profile,
     content::PageTransition transition, bool defer_load,
     SiteInstance* instance) const {
-  TabContentsWrapper* contents = TabContentsFactory(profile, instance,
-      MSG_ROUTING_NONE,
-      GetSelectedWebContents(), NULL);
+  TabContents* contents = TabContentsFactory(profile, instance,
+      MSG_ROUTING_NONE, GetActiveWebContents(), NULL);
   if (!defer_load) {
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
     contents->web_contents()->GetController().LoadURL(
         url, referrer, transition, std::string());
   }
 
   return contents;
 }
 
 bool Browser::CanDuplicateContentsAt(int index) {
   NavigationController& nc = GetWebContentsAt(index)->GetController();
   return nc.GetWebContents() && nc.GetLastCommittedEntry();
 }
 
 void Browser::DuplicateContentsAt(int index) {
-  TabContentsWrapper* contents = GetTabContentsWrapperAt(index);
+  TabContents* contents = GetTabContentsAt(index);
   CHECK(contents);
-  TabContentsWrapper* contents_dupe = contents->Clone();
+  TabContents* contents_dupe = contents->Clone();
 
   bool pinned = false;
   if (CanSupportWindowFeature(FEATURE_TABSTRIP)) {
     // If this is a tabbed browser, just create a duplicate tab inside the same
     // window next to the tab being duplicated.
     int index = tab_strip_model_->GetIndexOfTabContents(contents);
     pinned = IsTabPinned(index);
     int add_types = TabStripModel::ADD_ACTIVE |
         TabStripModel::ADD_INHERIT_GROUP |
         (pinned ? TabStripModel::ADD_PINNED : 0);
@@ skipping 35 matching lines @@
 #if !defined(OS_MACOSX)
   // This is scheduled to run after we return to the message loop because
   // otherwise the frame will think the drag session is still active and ignore
   // the request.
   // TODO(port): figure out what is required here in a cross-platform world
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&Browser::CloseFrame, weak_factory_.GetWeakPtr()));
 #endif
 }
 
-void Browser::CreateHistoricalTab(TabContentsWrapper* contents) {
+void Browser::CreateHistoricalTab(TabContents* contents) {
   // We don't create historical tabs for incognito windows or windows without
   // profiles.
   if (!profile() || profile()->IsOffTheRecord())
     return;
 
   // We don't create historical tabs for print preview tabs.
   if (contents->web_contents()->GetURL() == GURL(chrome::kChromeUIPrintURL))
     return;
 
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile());
 
   // We only create historical tab entries for tabbed browser windows.
   if (service && CanSupportWindowFeature(FEATURE_TABSTRIP)) {
     service->CreateHistoricalTab(&contents->web_contents()->GetController(),
         tab_strip_model_->GetIndexOfTabContents(contents));
   }
 }
 
-bool Browser::RunUnloadListenerBeforeClosing(TabContentsWrapper* contents) {
+bool Browser::RunUnloadListenerBeforeClosing(TabContents* contents) {
   return Browser::RunUnloadEventsHelper(contents->web_contents());
 }
 
 bool Browser::CanCloseContents(std::vector<int>* indices) {
   DCHECK(!indices->empty());
   TabCloseableStateWatcher* watcher =
       g_browser_process->tab_closeable_state_watcher();
   bool can_close_all = !watcher || watcher->CanCloseTabs(this, indices);
   if (indices->empty())  // Cannot close any tab.
     return false;
@@ skipping 44 matching lines @@
 bool Browser::LargeIconsPermitted() const {
   // We don't show the big icons in tabs for TYPE_EXTENSION_APP windows because
   // for those windows, we already have a big icon in the top-left outside any
   // tab. Having big tab icons too looks kinda redonk.
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelObserver implementation:
 
-void Browser::TabInsertedAt(TabContentsWrapper* contents,
+void Browser::TabInsertedAt(TabContents* contents,
                             int index,
                             bool foreground) {
   SetAsDelegate(contents, this);
   contents->restore_tab_helper()->SetWindowID(session_id());
 
   SyncHistoryWithTabs(index);
 
   // Make sure the loading state is updated correctly, otherwise the throbber
   // won't start if the page is loading.
   LoadingStateChanged(contents->web_contents());
 
   // If the tab crashes in the beforeunload or unload handler, it won't be
   // able to ack. But we know we can close it.
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                  content::Source<WebContents>(contents->web_contents()));
 
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                  content::Source<WebContents>(contents->web_contents()));
 
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_DETACHED,
                  content::Source<WebContents>(contents->web_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
-                           TabContentsWrapper* contents,
+                           TabContents* contents,
                            int index) {
   fullscreen_controller_->OnTabClosing(contents->web_contents());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(
           &contents->web_contents()->GetController()),
       content::NotificationService::NoDetails());
 
   // Sever the WebContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
-void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
+void Browser::TabDetachedAt(TabContents* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
 
-void Browser::TabDeactivated(TabContentsWrapper* contents) {
+void Browser::TabDeactivated(TabContents* contents) {
   fullscreen_controller_->OnTabDeactivated(contents);
   if (instant())
     instant()->Hide();
 
   // Save what the user's currently typing, so it can be restored when we
   // switch back to this tab.
   window_->GetLocationBar()->SaveStateToContents(contents->web_contents());
 }
 
-void Browser::ActiveTabChanged(TabContentsWrapper* old_contents,
-                               TabContentsWrapper* new_contents,
+void Browser::ActiveTabChanged(TabContents* old_contents,
+                               TabContents* new_contents,
                                int index,
                                bool user_gesture) {
   // On some platforms we want to automatically reload tabs that are
   // killed when the user selects them.
   bool did_reload = false;
   if (user_gesture && new_contents->web_contents()->GetCrashedStatus() ==
         base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
     const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
     if (parsed_command_line.HasSwitch(switches::kReloadKilledTabs)) {
       LOG(WARNING) << "Reloading killed tab at " << index;
@@ skipping 27 matching lines @@
   // Update commands to reflect current state.
   UpdateCommandsForTabState();
 
   // Reset the status bubble.
   StatusBubble* status_bubble = GetStatusBubble();
   if (status_bubble) {
     status_bubble->Hide();
 
     // Show the loading state (if any).
     status_bubble->SetStatus(
-        GetSelectedTabContentsWrapper()->core_tab_helper()->GetStatusText());
+        GetActiveTabContents()->core_tab_helper()->GetStatusText());
   }
 
   if (HasFindBarController()) {
     find_bar_controller_->ChangeTabContents(new_contents);
     find_bar_controller_->find_bar()->MoveWindowIfNecessary(gfx::Rect(), true);
   }
 
   // Update sessions. Don't force creation of sessions. If sessions doesn't
   // exist, the change will be picked up by sessions when created.
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service && !tab_strip_model_->closing_all()) {
     session_service->SetSelectedTabInWindow(session_id(), active_index());
   }
 
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_SWITCH);
 }
 
-void Browser::TabMoved(TabContentsWrapper* contents,
+void Browser::TabMoved(TabContents* contents,
                        int from_index,
                        int to_index) {
   DCHECK(from_index >= 0 && to_index >= 0);
   // Notify the history service.
   SyncHistoryWithTabs(std::min(from_index, to_index));
 }
 
 void Browser::TabReplacedAt(TabStripModel* tab_strip_model,
-                            TabContentsWrapper* old_contents,
-                            TabContentsWrapper* new_contents,
+                            TabContents* old_contents,
+                            TabContents* new_contents,
                             int index) {
   TabDetachedAtImpl(old_contents, index, DETACH_TYPE_REPLACE);
   TabInsertedAt(new_contents, index, (index == active_index()));
 
   int entry_count =
       new_contents->web_contents()->GetController().GetEntryCount();
   if (entry_count > 0) {
     // Send out notification so that observers are updated appropriately.
     new_contents->web_contents()->GetController().NotifyEntryChanged(
         new_contents->web_contents()->GetController().GetEntryAtIndex(
             entry_count - 1),
         entry_count - 1);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfile(profile());
   if (session_service) {
     // The new_contents may end up with a different navigation stack. Force
     // the session service to update itself.
     session_service->TabRestored(new_contents, IsTabPinned(index));
   }
 
   content::DevToolsManager::GetInstance()->ContentsReplaced(
       old_contents->web_contents(), new_contents->web_contents());
 }
 
-void Browser::TabPinnedStateChanged(TabContentsWrapper* contents, int index) {
+void Browser::TabPinnedStateChanged(TabContents* contents, int index) {
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     session_service->SetPinnedState(
         session_id(),
-        GetTabContentsWrapperAt(index)->restore_tab_helper()->session_id(),
+        GetTabContentsAt(index)->restore_tab_helper()->session_id(),
         IsTabPinned(index));
   }
 }
 
 void Browser::TabStripEmpty() {
   // Close the frame after we return to the message loop (not immediately,
   // otherwise it will destroy this object before the stack has a chance to
   // cleanly unwind.)
   // Note: This will be called several times if TabStripEmpty is called several
   //       times. This is because it does not close the window if tabs are
@@ skipping 11 matching lines @@
   fullscreen_controller_->OnAcceptFullscreenPermission(url, bubble_type);
 }
 
 void Browser::OnDenyFullscreenPermission(FullscreenExitBubbleType bubble_type) {
   fullscreen_controller_->OnDenyFullscreenPermission(bubble_type);
 }
 
 bool Browser::TabsNeedBeforeUnloadFired() {
   if (tabs_needing_before_unload_fired_.empty()) {
     for (int i = 0; i < tab_count(); ++i) {
-      WebContents* contents = GetTabContentsWrapperAt(i)->web_contents();
+      WebContents* contents = GetTabContentsAt(i)->web_contents();
       if (contents->NeedToFireBeforeUnload())
         tabs_needing_before_unload_fired_.insert(contents);
     }
   }
   return !tabs_needing_before_unload_fired_.empty();
 }
 
 bool Browser::IsFullscreenForTabOrPending() const {
   return fullscreen_controller_->IsFullscreenForTabOrPending();
 }
@@ skipping 40 matching lines @@
 
   return BrowserWindow::CreateBrowserWindow(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, content::WebContentsDelegate implementation:
 
 WebContents* Browser::OpenURLFromTab(WebContents* source,
                                      const OpenURLParams& params) {
   browser::NavigateParams nav_params(this, params.url, params.transition);
-  nav_params.source_contents = GetTabContentsWrapperAt(
+  nav_params.source_contents = GetTabContentsAt(
       tab_strip_model_->GetWrapperIndex(source));
   nav_params.referrer = params.referrer;
   nav_params.disposition = params.disposition;
   nav_params.tabstrip_add_types = TabStripModel::ADD_NONE;
   nav_params.window_action = browser::NavigateParams::SHOW_WINDOW;
   nav_params.user_gesture = true;
   nav_params.override_encoding = params.override_encoding;
   nav_params.is_renderer_initiated = params.is_renderer_initiated;
   nav_params.transferred_global_request_id =
       params.transferred_global_request_id;
@@ skipping 21 matching lines @@
 void Browser::AddNewContents(WebContents* source,
                              WebContents* new_contents,
                              WindowOpenDisposition disposition,
                              const gfx::Rect& initial_pos,
                              bool user_gesture) {
   // No code for this yet.
   DCHECK(disposition != SAVE_TO_DISK);
   // Can't create a new contents for the current tab - invalid case.
   DCHECK(disposition != CURRENT_TAB);
 
-  TabContentsWrapper* source_wrapper = NULL;
+  TabContents* source_tab_contents = NULL;
   BlockedContentTabHelper* source_blocked_content = NULL;
-  TabContentsWrapper* new_wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(new_contents);
-  if (!new_wrapper) {
-    new_wrapper = new TabContentsWrapper(new_contents);
+  TabContents* new_tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(new_contents);
+  if (!new_tab_contents) {
+    new_tab_contents = new TabContents(new_contents);
   }
   if (source) {
-    source_wrapper = TabContentsWrapper::GetCurrentWrapperForContents(source);
-    source_blocked_content = source_wrapper->blocked_content_tab_helper();
+    source_tab_contents =
+        TabContents::GetOwningTabContentsForWebContents(source);
+    source_blocked_content = source_tab_contents->blocked_content_tab_helper();
   }
 
-  if (source_wrapper) {
+  if (source_tab_contents) {
     // Handle blocking of all contents.
     if (source_blocked_content->all_contents_blocked()) {
-      source_blocked_content->AddTabContents(new_wrapper,
+      source_blocked_content->AddTabContents(new_tab_contents,
                                              disposition,
                                              initial_pos,
                                              user_gesture);
       return;
     }
 
     // Handle blocking of popups.
     if ((disposition == NEW_POPUP) && !user_gesture &&
         !CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisablePopupBlocking)) {
       // Unrequested popups from normal pages are constrained unless they're in
       // the whitelist.  The popup owner will handle checking this.
-      GetConstrainingContentsWrapper(source_wrapper)->
+      GetConstrainingContentsWrapper(source_tab_contents)->
           blocked_content_tab_helper()->
-              AddPopup(new_wrapper, initial_pos, user_gesture);
+              AddPopup(new_tab_contents, initial_pos, user_gesture);
       return;
     }
 
     new_contents->GetRenderViewHost()->DisassociateFromPopupCount();
   }
 
-  browser::NavigateParams params(this, new_wrapper);
+  browser::NavigateParams params(this, new_tab_contents);
   params.source_contents = source ?
-      GetTabContentsWrapperAt(tab_strip_model_->GetWrapperIndex(source)): NULL;
+      GetTabContentsAt(tab_strip_model_->GetWrapperIndex(source)): NULL;
   params.disposition = disposition;
   params.window_bounds = initial_pos;
   params.window_action = browser::NavigateParams::SHOW_WINDOW;
   params.user_gesture = user_gesture;
   browser::Navigate(&params);
 }
 
 void Browser::ActivateContents(WebContents* contents) {
   ActivateTabAt(tab_strip_model_->GetWrapperIndex(contents), false);
   window_->Activate();
 }
 
 void Browser::DeactivateContents(WebContents* contents) {
   window_->Deactivate();
 }
 
 void Browser::LoadingStateChanged(WebContents* source) {
   window_->UpdateLoadingAnimations(tab_strip_model_->TabsAreLoading());
   window_->UpdateTitleBar();
 
-  WebContents* selected_contents = GetSelectedWebContents();
+  WebContents* selected_contents = GetActiveWebContents();
   if (source == selected_contents) {
     bool is_loading = source->IsLoading();
     UpdateReloadStopState(is_loading, false);
     if (GetStatusBubble()) {
       GetStatusBubble()->SetStatus(
-          GetSelectedTabContentsWrapper()->core_tab_helper()->GetStatusText());
+          GetActiveTabContents()->core_tab_helper()->GetStatusText());
     }
 
     if (!is_loading && pending_web_app_action_ == UPDATE_SHORTCUT) {
       // Schedule a shortcut update when web application info is available if
       // last committed entry is not NULL. Last committed entry could be NULL
       // when an interstitial page is injected (e.g. bad https certificate,
       // malware site etc). When this happens, we abort the shortcut update.
       NavigationEntry* entry = source->GetController().GetLastCommittedEntry();
       if (entry) {
-        TabContentsWrapper::GetCurrentWrapperForContents(source)->
+        TabContents::GetOwningTabContentsForWebContents(source)->
             extension_tab_helper()->GetApplicationInfo(entry->GetPageID());
       } else {
         pending_web_app_action_ = NONE;
       }
     }
   }
 }
 
 void Browser::CloseContents(WebContents* source) {
   if (is_attempting_to_close_browser_) {
@@ skipping 35 matching lines @@
 
 bool Browser::CanReloadContents(WebContents* source) const {
   return !is_devtools();
 }
 
 void Browser::UpdateTargetURL(WebContents* source, int32 page_id,
                               const GURL& url) {
   if (!GetStatusBubble())
     return;
 
-  if (source == GetSelectedWebContents()) {
+  if (source == GetActiveWebContents()) {
     PrefService* prefs = profile_->GetPrefs();
     GetStatusBubble()->SetURL(url, prefs->GetString(prefs::kAcceptLanguages));
   }
 }
 
 void Browser::ContentsMouseEvent(
     WebContents* source, const gfx::Point& location, bool motion) {
   if (!GetStatusBubble())
     return;
 
-  if (source == GetSelectedWebContents()) {
+  if (source == GetActiveWebContents()) {
     GetStatusBubble()->MouseMoved(location, !motion);
     if (!motion)
       GetStatusBubble()->SetURL(GURL(), std::string());
   }
 }
 
 void Browser::ContentsZoomChange(bool zoom_in) {
   ExecuteCommand(zoom_in ? IDC_ZOOM_PLUS : IDC_ZOOM_MINUS);
 }
 
@@ skipping 14 matching lines @@
 }
 
 void Browser::ConvertContentsToApplication(WebContents* contents) {
   const GURL& url = contents->GetController().GetActiveEntry()->GetURL();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
 
   DetachContents(contents);
   Browser* app_browser = Browser::CreateWithParams(
       Browser::CreateParams::CreateForApp(
           TYPE_POPUP, app_name, gfx::Rect(), profile_));
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(contents);
-  if (!wrapper)
-    wrapper = new TabContentsWrapper(contents);
-  app_browser->tab_strip_model()->AppendTabContents(wrapper, true);
+  TabContents* tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(contents);
+  if (!tab_contents)
+    tab_contents = new TabContents(contents);
+  app_browser->tab_strip_model()->AppendTabContents(tab_contents, true);
 
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->GetRenderViewHost()->SyncRendererPrefs();
   app_browser->window()->Show();
 }
 
 gfx::Rect Browser::GetRootWindowResizerRect() const {
   return window_->GetRootWindowResizerRect();
 }
 
@@ skipping 43 matching lines @@
 void Browser::RenderWidgetShowing() {
   window_->DisableInactiveFrame();
 }
 
 int Browser::GetExtraRenderViewHeight() const {
   return window_->GetExtraRenderViewHeight();
 }
 
 void Browser::OnStartDownload(WebContents* source,
                               content::DownloadItem* download) {
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(source);
-  TabContentsWrapper* constrained = GetConstrainingContentsWrapper(wrapper);
-  if (constrained != wrapper) {
+  TabContents* tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(source);
+  TabContents* constrained = GetConstrainingContentsWrapper(tab_contents);
+  if (constrained != tab_contents) {
     // Download in a constrained popup is shown in the tab that opened it.
     WebContents* constrained_tab = constrained->web_contents();
     constrained_tab->GetDelegate()->OnStartDownload(constrained_tab, download);
     return;
   }
 
   if (!window())
     return;
 
   if (DisplayOldDownloadsUI()) {
     // GetDownloadShelf creates the download shelf if it was not yet created.
     DownloadShelf* shelf = window()->GetDownloadShelf();
     shelf->AddDownload(new DownloadItemModel(download));
     // Don't show the animation for "Save file" downloads.
     // For non-theme extensions, we don't show the download animation.
     // Show animation in same window as the download shelf. Download shelf
     // may not be in the same window that initiated the download, e.g.
     // Panels.
     // Don't show the animation if the selected tab is not visible (i.e. the
     // window is minimized, we're in a unit test, etc.).
-    WebContents* shelf_tab = shelf->browser()->GetSelectedWebContents();
+    WebContents* shelf_tab = shelf->browser()->GetActiveWebContents();
     if ((download->GetTotalBytes() > 0) &&
         !download_crx_util::IsExtensionDownload(*download) &&
         platform_util::IsVisible(shelf_tab->GetNativeView()) &&
         ui::Animation::ShouldRenderRichAnimation()) {
       DownloadStartedAnimation::Show(shelf_tab);
     }
   }
 
   // If the download occurs in a new tab, close it.
   if (source->GetController().IsInitialNavigation() && tab_count() > 1)
     CloseContents(source);
 }
 
 void Browser::ViewSourceForTab(WebContents* source, const GURL& page_url) {
   DCHECK(source);
-  TabContentsWrapper* wrapper = GetTabContentsWrapperAt(
+  TabContents* tab_contents = GetTabContentsAt(
       tab_strip_model_->GetWrapperIndex(source));
-  ViewSource(wrapper);
+  ViewSource(tab_contents);
 }
 
 void Browser::ViewSourceForFrame(WebContents* source,
                                  const GURL& frame_url,
                                  const std::string& frame_content_state) {
   DCHECK(source);
-  TabContentsWrapper* wrapper = GetTabContentsWrapperAt(
+  TabContents* tab_contents = GetTabContentsAt(
       tab_strip_model_->GetWrapperIndex(source));
-  ViewSource(wrapper, frame_url, frame_content_state);
+  ViewSource(tab_contents, frame_url, frame_content_state);
 }
 
 bool Browser::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                      bool* is_keyboard_shortcut) {
   // Escape exits tabbed fullscreen mode.
   // TODO(koz): Write a test for this http://crbug.com/100441.
   if (event.windowsKeyCode == 27 &&
       fullscreen_controller_->HandleUserPressedEscape()) {
     return true;
   }
   return window()->PreHandleKeyboardEvent(event, is_keyboard_shortcut);
 }
 
 void Browser::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
   window()->HandleKeyboardEvent(event);
 }
 
 void Browser::ShowRepostFormWarningDialog(WebContents* source) {
   browser::ShowTabModalConfirmDialog(
       new RepostFormWarningController(source),
-      TabContentsWrapper::GetCurrentWrapperForContents(source));
+      TabContents::GetOwningTabContentsForWebContents(source));
 }
 
 bool Browser::ShouldAddNavigationToHistory(
     const history::HistoryAddPageArgs& add_page_args,
     content::NavigationType navigation_type) {
   // Don't update history if running as app.
   return !IsApplication();
 }
 
 bool Browser::ShouldCreateWebContents(
     WebContents* web_contents,
     int route_id,
     WindowContainerType window_container_type,
     const string16& frame_name,
     const GURL& target_url) {
   if (window_container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
     // If a BackgroundContents is created, suppress the normal WebContents.
     return !MaybeCreateBackgroundContents(
         route_id, web_contents, frame_name, target_url);
   }
 
   return true;
 }
 
 void Browser::WebContentsCreated(WebContents* source_contents,
                                  int64 source_frame_id,
                                  const GURL& target_url,
                                  WebContents* new_contents) {
-  // Create a TabContentsWrapper now, so all observers are in place, as the
-  // network requests for its initial navigation will start immediately. The
-  // WebContents will later be inserted into this browser using
-  // Browser::Navigate via AddNewContents. The latter will retrieve the newly
-  // created TabContentsWrapper from WebContents object.
-  new TabContentsWrapper(new_contents);
+  // Create a TabContents now, so all observers are in place, as the network
+  // requests for its initial navigation will start immediately. The WebContents
+  // will later be inserted into this browser using Browser::Navigate via
+  // AddNewContents. The latter will retrieve the newly created TabContents from
+  // WebContents object.
+  new TabContents(new_contents);
 
   // Notify.
   RetargetingDetails details;
   details.source_web_contents = source_contents;
   details.source_frame_id = source_frame_id;
   details.target_url = target_url;
   details.target_web_contents = new_contents;
   details.not_yet_in_tabstrip = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_RETARGETING,
       content::Source<Profile>(profile_),
       content::Details<RetargetingDetails>(&details));
 }
 
 void Browser::ContentRestrictionsChanged(WebContents* source) {
   UpdateCommandsForContentRestrictionState();
 }
 
 void Browser::RendererUnresponsive(WebContents* source) {
   // Ignore hangs if print preview is open.
-  TabContentsWrapper* source_wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(source);
-  if (source_wrapper) {
+  TabContents* tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(source);
+  if (tab_contents) {
     printing::PrintPreviewTabController* controller =
         printing::PrintPreviewTabController::GetInstance();
     if (controller) {
-      TabContentsWrapper* preview_tab =
-          controller->GetPrintPreviewForTab(source_wrapper);
-      if (preview_tab && preview_tab != source_wrapper) {
+      TabContents* preview_tab =
+          controller->GetPrintPreviewForTab(tab_contents);
+      if (preview_tab && preview_tab != tab_contents) {
         return;
       }
     }
   }
 
   browser::ShowHungRendererDialog(source);
 }
 
 void Browser::RendererResponsive(WebContents* source) {
   browser::HideHungRendererDialog(source);
 }
 
 void Browser::WorkerCrashed(WebContents* source) {
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(source);
-  InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
+  TabContents* tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(source);
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   infobar_helper->AddInfoBar(new SimpleAlertInfoBarDelegate(
       infobar_helper,
       NULL,
       l10n_util::GetStringUTF16(IDS_WEBWORKER_CRASHED_PROMPT),
       true));
 }
 
 void Browser::DidNavigateMainFramePostCommit(WebContents* tab) {
-  if (tab == GetSelectedWebContents())
+  if (tab == GetActiveWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 void Browser::DidNavigateToPendingEntry(WebContents* tab) {
-  if (tab == GetSelectedWebContents())
+  if (tab == GetActiveWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 content::JavaScriptDialogCreator* Browser::GetJavaScriptDialogCreator() {
   return GetJavaScriptDialogCreatorInstance();
 }
 
 content::ColorChooser* Browser::OpenColorChooser(WebContents* tab,
                                                  int color_chooser_id,
                                                  SkColor color) {
@@ skipping 55 matching lines @@
   RegisterIntentHandlerHelper(tab, data, user_gesture);
 }
 
 void Browser::WebIntentDispatch(
     WebContents* tab, content::WebIntentsDispatcher* intents_dispatcher) {
   if (!web_intents::IsWebIntentsEnabledForProfile(profile_))
     return;
 
   UMA_HISTOGRAM_COUNTS("WebIntents.Dispatch", 1);
 
-  TabContentsWrapper* tcw =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  tcw->web_intent_picker_controller()->SetIntentsDispatcher(intents_dispatcher);
-  tcw->web_intent_picker_controller()->ShowDialog(
+  TabContents* tab_contents =
+      TabContents::GetOwningTabContentsForWebContents(tab);
+  tab_contents->web_intent_picker_controller()->SetIntentsDispatcher(
+      intents_dispatcher);
+  tab_contents->web_intent_picker_controller()->ShowDialog(
       intents_dispatcher->GetIntent().action,
       intents_dispatcher->GetIntent().type);
 }
 
 void Browser::UpdatePreferredSize(WebContents* source,
                                   const gfx::Size& pref_size) {
   window_->UpdatePreferredSize(source, pref_size);
 }
 
 void Browser::ResizeDueToAutoResize(WebContents* source,
@@ skipping 19 matching lines @@
                                              last_unlocked_by_target);
 }
 
 void Browser::LostMouseLock() {
   fullscreen_controller_->LostMouseLock();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CoreTabHelperDelegate implementation:
 
-void Browser::SwapTabContents(TabContentsWrapper* old_tab_contents,
-                              TabContentsWrapper* new_tab_contents) {
+void Browser::SwapTabContents(TabContents* old_tab_contents,
+                              TabContents* new_tab_contents) {
   int index = tab_strip_model_->GetIndexOfTabContents(old_tab_contents);
   DCHECK_NE(TabStripModel::kNoTab, index);
   tab_strip_model_->ReplaceTabContentsAt(index, new_tab_contents);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, SearchEngineTabHelperDelegate implementation:
 
 void Browser::ConfirmAddSearchProvider(TemplateURL* template_url,
                                        Profile* profile) {
   window()->ConfirmAddSearchProvider(template_url, profile);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, ConstrainedWindowTabHelperDelegate implementation:
 
-void Browser::SetTabContentBlocked(TabContentsWrapper* wrapper, bool blocked) {
-  int index = tab_strip_model_->GetIndexOfTabContents(wrapper);
+void Browser::SetTabContentBlocked(TabContents* tab_contents, bool blocked) {
+  int index = tab_strip_model_->GetIndexOfTabContents(tab_contents);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED();
     return;
   }
   tab_strip_model_->SetTabBlocked(index, blocked);
-  UpdatePrintingState(wrapper->web_contents()->GetContentRestrictions());
-  if (!blocked && GetSelectedTabContentsWrapper() == wrapper)
-    wrapper->web_contents()->Focus();
+  UpdatePrintingState(tab_contents->web_contents()->GetContentRestrictions());
+  if (!blocked && GetActiveTabContents() == tab_contents)
+    tab_contents->web_contents()->Focus();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, BlockedContentTabHelperDelegate implementation:
 
-TabContentsWrapper* Browser::GetConstrainingContentsWrapper(
-  TabContentsWrapper* source) {
+TabContents* Browser::GetConstrainingContentsWrapper(TabContents* source) {
   return source;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, BookmarkTabHelperDelegate implementation:
 
-void Browser::URLStarredChanged(TabContentsWrapper* source, bool starred) {
-  if (source == GetSelectedTabContentsWrapper())
+void Browser::URLStarredChanged(TabContents* source, bool starred) {
+  if (source == GetActiveTabContents())
     window_->SetStarredState(starred);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, ZoomObserver implementation:
 
-void Browser::OnZoomIconChanged(TabContentsWrapper* source,
+void Browser::OnZoomIconChanged(TabContents* source,
                                 ZoomController::ZoomIconState state) {
-  if (source == GetSelectedTabContentsWrapper())
+  if (source == GetActiveTabContents())
     window_->SetZoomIconState(state);
 }
 
-void Browser::OnZoomChanged(TabContentsWrapper* source,
+void Browser::OnZoomChanged(TabContents* source,
                             int zoom_percent,
                             bool can_show_bubble) {
-  if (source == GetSelectedTabContentsWrapper()) {
+  if (source == GetActiveTabContents()) {
     window_->SetZoomIconTooltipPercent(zoom_percent);
 
     // Only show the zoom bubble for zoom changes in the active window.
     if (can_show_bubble && window_->IsActive())
       window_->ShowZoomBubble(zoom_percent);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, ExtensionTabHelperDelegate implementation:
 
-void Browser::OnDidGetApplicationInfo(TabContentsWrapper* source,
+void Browser::OnDidGetApplicationInfo(TabContents* source,
                                       int32 page_id) {
-  if (GetSelectedTabContentsWrapper() != source)
+  if (GetActiveTabContents() != source)
     return;
 
   NavigationEntry* entry =
       source->web_contents()->GetController().GetLastCommittedEntry();
   if (!entry || (entry->GetPageID() != page_id))
     return;
 
   switch (pending_web_app_action_) {
     case CREATE_SHORTCUT: {
       window()->ShowCreateWebAppShortcutsDialog(source);
       break;
     }
     case UPDATE_SHORTCUT: {
       web_app::UpdateShortcutForTabContents(source);
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 
   pending_web_app_action_ = NONE;
 }
 
-void Browser::OnInstallApplication(TabContentsWrapper* source,
+void Browser::OnInstallApplication(TabContents* source,
                                    const WebApplicationInfo& web_app) {
   ExtensionService* extension_service = profile()->GetExtensionService();
   if (!extension_service)
     return;
 
   scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(
       extension_service,
       extension_service->show_extensions_prompts() ?
       new ExtensionInstallUI(profile()) : NULL));
   installer->InstallWebApp(web_app);
@@ skipping 34 matching lines @@
       }
       break;
 
     case content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED:
       // When the current tab's SSL state changes, we need to update the URL
       // bar to reflect the new state. Note that it's possible for the selected
       // tab contents to be NULL. This is because we listen for all sources
       // (NavigationControllers) for convenience, so the notification could
       // actually be for a different window while we're doing asynchronous
       // closing of this one.
-      if (GetSelectedWebContents() &&
-          &GetSelectedWebContents()->GetController() ==
+      if (GetActiveWebContents() &&
+          &GetActiveWebContents()->GetController() ==
           content::Source<NavigationController>(source).ptr())
         UpdateToolbar(false);
       break;
 
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       if (window()->GetLocationBar())
         window()->GetLocationBar()->UpdatePageActions();
 
       // Close any tabs from the unloaded extension, unless it's terminated,
       // in which case let the sad tabs remain.
@@ skipping 79 matching lines @@
       } else if (pref_name == prefs::kInManagedMode) {
         UpdateCommandsForMultipleProfiles();
       } else {
         NOTREACHED();
       }
       break;
     }
 
     case chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED: {
       WebContents* web_contents = content::Source<WebContents>(source).ptr();
-      if (web_contents == GetSelectedWebContents()) {
+      if (web_contents == GetActiveWebContents()) {
         LocationBar* location_bar = window()->GetLocationBar();
         if (location_bar)
           location_bar->UpdateContentSettingsIcons();
       }
       break;
     }
 
     case content::NOTIFICATION_INTERSTITIAL_ATTACHED:
       UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
       UpdateCommandsForTabState();
@@ skipping 19 matching lines @@
   if (!window_)
     return;
   const bool show_main_ui = IsShowingMainUI(window_->IsFullscreen());
   command_updater_.UpdateCommandEnabled(IDC_SHOW_SYNC_SETUP,
       show_main_ui && profile_->GetOriginalProfile()->IsSyncAccessible());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, InstantDelegate implementation:
 
-void Browser::ShowInstant(TabContentsWrapper* preview_contents) {
+void Browser::ShowInstant(TabContents* preview_contents) {
   window_->ShowInstant(preview_contents);
 
-  GetSelectedWebContents()->HideContents();
+  GetActiveWebContents()->HideContents();
   preview_contents->web_contents()->ShowContents();
 }
 
 void Browser::HideInstant() {
   window_->HideInstant();
-  if (GetSelectedWebContents())
-    GetSelectedWebContents()->ShowContents();
+  if (GetActiveWebContents())
+    GetActiveWebContents()->ShowContents();
   if (instant_->GetPreviewContents())
     instant_->GetPreviewContents()->web_contents()->HideContents();
 }
 
-void Browser::CommitInstant(TabContentsWrapper* preview_contents) {
-  TabContentsWrapper* tab_contents = GetSelectedTabContentsWrapper();
+void Browser::CommitInstant(TabContents* preview_contents) {
+  TabContents* tab_contents = GetActiveTabContents();
   int index = tab_strip_model_->GetIndexOfTabContents(tab_contents);
   DCHECK_NE(TabStripModel::kNoTab, index);
   // TabStripModel takes ownership of preview_contents.
   tab_strip_model_->ReplaceTabContentsAt(index, preview_contents);
   // InstantUnloadHandler takes ownership of tab_contents.
   instant_unload_handler_->RunUnloadListenersOrDestroy(tab_contents, index);
 
   GURL url = preview_contents->web_contents()->GetURL();
   DCHECK(profile_->GetExtensionService());
   if (profile_->GetExtensionService()->IsInstalledApp(url)) {
@@ skipping 10 matching lines @@
 
 gfx::Rect Browser::GetInstantBounds() {
   return window()->GetInstantBounds();
 }
 
 void Browser::InstantPreviewFocused() {
   // NOTE: This is only invoked on aura.
   window_->WebContentsFocused(instant_->GetPreviewContents()->web_contents());
 }
 
-TabContentsWrapper* Browser::GetInstantHostTabContents() const {
-  return GetSelectedTabContentsWrapper();
+TabContents* Browser::GetInstantHostTabContents() const {
+  return GetActiveTabContents();
 }
 
-
-
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Command and state updating (private):
 
 bool Browser::IsShowingMainUI(bool is_fullscreen) {
 #if !defined(OS_MACOSX)
   return is_type_tabbed() && !is_fullscreen;
 #else
   return is_type_tabbed();
 #endif
 }
@@ skipping 164 matching lines @@
                                         enable_extensions && command_enabled);
 
   const bool show_main_ui = IsShowingMainUI(window_ && window_->IsFullscreen());
   command_updater_.UpdateCommandEnabled(IDC_IMPORT_SETTINGS,
                                         show_main_ui && command_enabled);
   command_updater_.UpdateCommandEnabled(IDC_OPTIONS,
                                         show_main_ui && command_enabled);
 }
 
 void Browser::UpdateCommandsForTabState() {
-  WebContents* current_tab = GetSelectedWebContents();
-  TabContentsWrapper* current_tab_wrapper = GetSelectedTabContentsWrapper();
-  if (!current_tab || !current_tab_wrapper)  // May be NULL during tab restore.
+  TabContents* current_tab_contents = GetActiveTabContents();
+  if (!current_tab_contents)  // May be NULL during tab restore.
     return;
+  WebContents* current_web_contents = current_tab_contents->web_contents();
 
   // Navigation commands
-  NavigationController& nc = current_tab->GetController();
+  NavigationController& nc = current_web_contents->GetController();
   command_updater_.UpdateCommandEnabled(IDC_BACK, nc.CanGoBack());
   command_updater_.UpdateCommandEnabled(IDC_FORWARD, nc.CanGoForward());
-  command_updater_.UpdateCommandEnabled(IDC_RELOAD,
-                                        CanReloadContents(current_tab));
-  command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE,
-                                        CanReloadContents(current_tab));
+  command_updater_.UpdateCommandEnabled(
+      IDC_RELOAD, CanReloadContents(current_web_contents));
+  command_updater_.UpdateCommandEnabled(
+      IDC_RELOAD_IGNORING_CACHE, CanReloadContents(current_web_contents));
 
   // Window management commands
   command_updater_.UpdateCommandEnabled(IDC_DUPLICATE_TAB,
       !is_app() && CanDuplicateContentsAt(active_index()));
 
   // Page-related commands
   window_->SetStarredState(
-      current_tab_wrapper->bookmark_tab_helper()->is_starred());
+      current_tab_contents->bookmark_tab_helper()->is_starred());
   window_->SetZoomIconState(
-      current_tab_wrapper->zoom_controller()->zoom_icon_state());
+      current_tab_contents->zoom_controller()->zoom_icon_state());
   window_->SetZoomIconTooltipPercent(
-      current_tab_wrapper->zoom_controller()->zoom_percent());
+      current_tab_contents->zoom_controller()->zoom_percent());
   command_updater_.UpdateCommandEnabled(IDC_VIEW_SOURCE,
-      current_tab->GetController().CanViewSource());
+      current_web_contents->GetController().CanViewSource());
   command_updater_.UpdateCommandEnabled(IDC_EMAIL_PAGE_LOCATION,
-      toolbar_model_->ShouldDisplayURL() && current_tab->GetURL().is_valid());
+      toolbar_model_->ShouldDisplayURL() &&
+          current_web_contents->GetURL().is_valid());
   if (is_devtools())
       command_updater_.UpdateCommandEnabled(IDC_OPEN_FILE, false);
 
   // Changing the encoding is not possible on Chrome-internal webpages.
   bool is_chrome_internal = HasInternalURL(nc.GetActiveEntry()) ||
-      current_tab->ShowingInterstitialPage();
+      current_web_contents->ShowingInterstitialPage();
   command_updater_.UpdateCommandEnabled(IDC_ENCODING_MENU,
-      !is_chrome_internal && current_tab->IsSavable());
+      !is_chrome_internal && current_web_contents->IsSavable());
 
   // Show various bits of UI
   // TODO(pinkerton): Disable app-mode in the model until we implement it
   // on the Mac. Be sure to remove both ifdefs. http://crbug.com/13148
 #if !defined(OS_MACOSX)
   command_updater_.UpdateCommandEnabled(IDC_CREATE_SHORTCUTS,
-      web_app::IsValidUrl(current_tab->GetURL()));
+      web_app::IsValidUrl(current_web_contents->GetURL()));
 #endif
 
   UpdateCommandsForContentRestrictionState();
   UpdateCommandsForBookmarkEditing();
 }
 
 void Browser::UpdateCommandsForContentRestrictionState() {
   int restrictions = GetContentRestrictionsForSelectedTab();
 
   command_updater_.UpdateCommandEnabled(
@@ skipping 101 matching lines @@
 void Browser::UpdatePrintingState(int content_restrictions) {
   bool print_enabled = true;
   bool advanced_print_enabled = true;
   if (g_browser_process->local_state()) {
     print_enabled =
         g_browser_process->local_state()->GetBoolean(prefs::kPrintingEnabled);
     advanced_print_enabled = print_enabled;
   }
   if (print_enabled) {
     // Do not print when a constrained window is showing. It's confusing.
-    TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
-    bool has_constrained_window = (wrapper &&
-        wrapper->constrained_window_tab_helper()->constrained_window_count());
+    TabContents* tab_contents = GetActiveTabContents();
+    bool has_constrained_window =
+        tab_contents &&
+            tab_contents->constrained_window_tab_helper()->
+                constrained_window_count();
     if (has_constrained_window ||
         content_restrictions & content::CONTENT_RESTRICTION_PRINT) {
       print_enabled = false;
       advanced_print_enabled = false;
     }
 
     // The exception is print preview,
     // where advanced printing is always enabled.
     printing::PrintPreviewTabController* controller =
         printing::PrintPreviewTabController::GetInstance();
-    if (controller && (controller->GetPrintPreviewForTab(wrapper) ||
+    if (controller && (controller->GetPrintPreviewForTab(tab_contents) ||
                        controller->is_creating_print_preview_tab())) {
       advanced_print_enabled = true;
     }
   }
   command_updater_.UpdateCommandEnabled(IDC_PRINT, print_enabled);
   command_updater_.UpdateCommandEnabled(IDC_ADVANCED_PRINT,
                                         advanced_print_enabled);
 }
 
 void Browser::UpdateSaveAsState(int content_restrictions) {
@@ skipping 16 matching lines @@
 
 void Browser::UpdateReloadStopState(bool is_loading, bool force) {
   window_->UpdateReloadStopState(is_loading, force);
   command_updater_.UpdateCommandEnabled(IDC_STOP, is_loading);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, UI update coalescing and handling (private):
 
 void Browser::UpdateToolbar(bool should_restore_state) {
-  window_->UpdateToolbar(GetSelectedTabContentsWrapper(), should_restore_state);
+  window_->UpdateToolbar(GetActiveTabContents(), should_restore_state);
 }
 
 void Browser::ScheduleUIUpdate(const WebContents* source,
                                unsigned changed_flags) {
   if (!source)
     return;
 
   // Do some synchronous updates.
   if (changed_flags & content::INVALIDATE_TYPE_URL &&
-      source == GetSelectedWebContents()) {
+      source == GetActiveWebContents()) {
     // Only update the URL for the current tab. Note that we do not update
     // the navigation commands since those would have already been updated
     // synchronously by NavigationStateChanged.
     UpdateToolbar(false);
     changed_flags &= ~content::INVALIDATE_TYPE_URL;
   }
   if (changed_flags & content::INVALIDATE_TYPE_LOAD) {
     // Update the loading state synchronously. This is so the throbber will
     // immediately start/stop, which gives a more snappy feel. We want to do
     // this for any tab so they start & stop quickly.
@@ skipping 51 matching lines @@
 #endif
 
   chrome_updater_factory_.InvalidateWeakPtrs();
 
   for (UpdateMap::const_iterator i = scheduled_updates_.begin();
        i != scheduled_updates_.end(); ++i) {
     // Do not dereference |contents|, it may be out-of-date!
     const WebContents* contents = i->first;
     unsigned flags = i->second;
 
-    if (contents == GetSelectedWebContents()) {
+    if (contents == GetActiveWebContents()) {
       // Updates that only matter when the tab is selected go here.
 
       if (flags & content::INVALIDATE_TYPE_PAGE_ACTIONS) {
         LocationBar* location_bar = window()->GetLocationBar();
         if (location_bar)
           location_bar->UpdatePageActions();
       }
       // Updating the URL happens synchronously in ScheduleUIUpdate.
       if (flags & content::INVALIDATE_TYPE_LOAD && GetStatusBubble()) {
         GetStatusBubble()->SetStatus(
-            GetSelectedTabContentsWrapper()->
+            GetActiveTabContents()->
                 core_tab_helper()->GetStatusText());
       }
 
       if (flags & (content::INVALIDATE_TYPE_TAB |
                    content::INVALIDATE_TYPE_TITLE)) {
 // TODO(pinkerton): Disable app-mode in the model until we implement it
 // on the Mac. Be sure to remove both ifdefs. http://crbug.com/13148
 #if !defined(OS_MACOSX)
         command_updater_.UpdateCommandEnabled(IDC_CREATE_SHORTCUTS,
             web_app::IsValidUrl(contents->GetURL()));
@@ skipping 39 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Session restore functions (private):
 
 void Browser::SyncHistoryWithTabs(int index) {
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     for (int i = index; i < tab_count(); ++i) {
-      TabContentsWrapper* tab = GetTabContentsWrapperAt(i);
+      TabContents* tab = GetTabContentsAt(i);
       if (tab) {
         session_service->SetTabIndexInWindow(
             session_id(), tab->restore_tab_helper()->session_id(), i);
         session_service->SetPinnedState(
             session_id(),
             tab->restore_tab_helper()->session_id(),
             IsTabPinned(i));
       }
     }
   }
@@ skipping 125 matching lines @@
   window_->ConfirmBrowserCloseWithPendingDownloads();
 
   // Return false so the browser does not close.  We'll close if the user
   // confirms in the dialog.
   return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Assorted utility functions (private):
 
-void Browser::SetAsDelegate(TabContentsWrapper* tab, Browser* delegate) {
+void Browser::SetAsDelegate(TabContents* tab, Browser* delegate) {
   // WebContents...
   tab->web_contents()->SetDelegate(delegate);
 
   // ...and all the helpers.
   tab->blocked_content_tab_helper()->set_delegate(delegate);
   tab->bookmark_tab_helper()->set_delegate(delegate);
   tab->zoom_controller()->set_observer(delegate);
   tab->constrained_window_tab_helper()->set_delegate(delegate);
   tab->core_tab_helper()->set_delegate(delegate);
   tab->extension_tab_helper()->set_delegate(delegate);
   tab->search_engine_tab_helper()->set_delegate(delegate);
 }
 
 void Browser::FindInPage(bool find_next, bool forward_direction) {
   ShowFindBar();
   if (find_next) {
     string16 find_text;
 #if defined(OS_MACOSX)
     // We always want to search for the contents of the find pasteboard on OS X.
     find_text = GetFindPboardText();
 #endif
-    GetSelectedTabContentsWrapper()->
+    GetActiveTabContents()->
         find_tab_helper()->StartFinding(find_text,
                                         forward_direction,
                                         false);  // Not case sensitive.
   }
 }
 
 void Browser::CloseFrame() {
   window_->Close();
 }
 
-void Browser::TabDetachedAtImpl(TabContentsWrapper* contents, int index,
+void Browser::TabDetachedAtImpl(TabContents* contents, int index,
                                 DetachType type) {
   if (type == DETACH_TYPE_DETACH) {
     // Save the current location bar state, but only if the tab being detached
     // is the selected tab.  Because saving state can conditionally revert the
     // location bar, saving the current tab's location bar state to a
     // non-selected tab can corrupt both tabs.
-    if (contents == GetSelectedTabContentsWrapper()) {
+    if (contents == GetActiveTabContents()) {
       LocationBar* location_bar = window()->GetLocationBar();
       if (location_bar)
         location_bar->SaveStateToContents(contents->web_contents());
     }
 
     if (!tab_strip_model_->closing_all())
       SyncHistoryWithTabs(0);
   }
 
   SetAsDelegate(contents, NULL);
@@ skipping 28 matching lines @@
   PrefService* prefs = profile->GetPrefs();
   if (!prefs->FindPreference(window_pref.c_str())) {
     prefs->RegisterDictionaryPref(window_pref.c_str(),
                                   PrefService::UNSYNCABLE_PREF);
   }
 }
 
 void Browser::ReloadInternal(WindowOpenDisposition disposition,
                              bool ignore_cache) {
   // If we are showing an interstitial, treat this as an OpenURL.
-  WebContents* current_tab = GetSelectedWebContents();
+  WebContents* current_tab = GetActiveWebContents();
   if (current_tab && current_tab->ShowingInterstitialPage()) {
     NavigationEntry* entry = current_tab->GetController().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
     OpenURL(OpenURLParams(
         entry->GetURL(), Referrer(), disposition,
         content::PAGE_TRANSITION_RELOAD, false));
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
   //
   // Also notify RenderViewHostDelegate of the user gesture; this is
   // normally done in Browser::Navigate, but a reload bypasses Navigate.
   WebContents* tab = GetOrCloneTabForDisposition(disposition);
   tab->UserGestureDone();
   if (!tab->FocusLocationBarByDefault())
     tab->Focus();
   if (ignore_cache)
     tab->GetController().ReloadIgnoringCache(true);
   else
     tab->GetController().Reload(true);
 }
 
 WebContents* Browser::GetOrCloneTabForDisposition(
        WindowOpenDisposition disposition) {
-  TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
+  TabContents* current_tab = GetActiveTabContents();
   switch (disposition) {
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB: {
       current_tab = current_tab->Clone();
       tab_strip_model_->AddTabContents(
           current_tab, -1, content::PAGE_TRANSITION_LINK,
           disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_ACTIVE :
                                               TabStripModel::ADD_NONE);
       break;
     }
@@ skipping 56 matching lines @@
   if (!instant() || !instant()->PrepareForCommit() ||
       disposition == NEW_BACKGROUND_TAB) {
     // NEW_BACKGROUND_TAB results in leaving the omnibox open, so we don't
     // attempt to use the instant preview.
     return false;
   }
 
   if (disposition == CURRENT_TAB) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_COMMITTED,
-        content::Source<TabContentsWrapper>(instant()->CommitCurrentPreview(
+        content::Source<TabContents>(instant()->CommitCurrentPreview(
             INSTANT_COMMIT_PRESSED_ENTER)),
         content::NotificationService::NoDetails());
     return true;
   }
   if (disposition == NEW_FOREGROUND_TAB) {
-    TabContentsWrapper* preview_contents = instant()->ReleasePreviewContents(
+    TabContents* preview_contents = instant()->ReleasePreviewContents(
         INSTANT_COMMIT_PRESSED_ENTER, NULL);
     // HideInstant is invoked after release so that InstantController is not
     // active when HideInstant asks it for its state.
     HideInstant();
     preview_contents->web_contents()->GetController().PruneAllButActive();
     tab_strip_model_->AddTabContents(
         preview_contents,
         -1,
         instant()->last_transition_type(),
         TabStripModel::ADD_ACTIVE);
     instant()->CompleteRelease(preview_contents);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_COMMITTED,
-        content::Source<TabContentsWrapper>(preview_contents),
+        content::Source<TabContents>(preview_contents),
         content::NotificationService::NoDetails());
     return true;
   }
   // The omnibox currently doesn't use other dispositions, so we don't attempt
   // to handle them. If you hit this NOTREACHED file a bug and I'll (sky) add
   // support for the new disposition.
   NOTREACHED();
   return false;
 }
 
 void Browser::CreateInstantIfNecessary() {
   if (is_type_tabbed() && InstantController::IsEnabled(profile()) &&
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(this, InstantController::INSTANT));
     instant_unload_handler_.reset(new InstantUnloadHandler(this));
   }
 }
 
-void Browser::ViewSource(TabContentsWrapper* contents) {
+void Browser::ViewSource(TabContents* contents) {
   DCHECK(contents);
 
   NavigationEntry* active_entry =
       contents->web_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   ViewSource(contents, active_entry->GetURL(), active_entry->GetContentState());
 }
 
-void Browser::ViewSource(TabContentsWrapper* contents,
+void Browser::ViewSource(TabContents* contents,
                          const GURL& url,
                          const std::string& content_state) {
   content::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
-  TabContentsWrapper* view_source_contents = contents->Clone();
+  TabContents* view_source_contents = contents->Clone();
   view_source_contents->web_contents()->GetController().PruneAllButActive();
   NavigationEntry* active_entry =
       view_source_contents->web_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   GURL view_source_url = GURL(chrome::kViewSourceScheme + std::string(":") +
       url.spec());
   active_entry->SetVirtualURL(view_source_url);
 
@@ skipping 32 matching lines @@
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
 }
 
 int Browser::GetContentRestrictionsForSelectedTab() {
   int content_restrictions = 0;
-  WebContents* current_tab = GetSelectedWebContents();
+  WebContents* current_tab = GetActiveWebContents();
   if (current_tab) {
     content_restrictions = current_tab->GetContentRestrictions();
     NavigationEntry* active_entry =
         current_tab->GetController().GetActiveEntry();
     // See comment in UpdateCommandsForTabState about why we call url().
     if (!download_util::IsSavableURL(
             active_entry ? active_entry->GetURL() : GURL())
         || current_tab->ShowingInterstitialPage())
       content_restrictions |= content::CONTENT_RESTRICTION_SAVE;
     if (current_tab->ShowingInterstitialPage())
       content_restrictions |= content::CONTENT_RESTRICTION_PRINT;
   }
   return content_restrictions;
 }
 
 void Browser::UpdateBookmarkBarState(BookmarkBarStateChangeReason reason) {
   BookmarkBar::State state;
   // The bookmark bar is hidden in fullscreen mode, unless on the new tab page.
   if (browser_defaults::bookmarks_enabled &&
       profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar) &&
       (!window_ || !window_->IsFullscreen())) {
     state = BookmarkBar::SHOW;
   } else {
-    TabContentsWrapper* tab = GetSelectedTabContentsWrapper();
+    TabContents* tab = GetActiveTabContents();
     if (tab && tab->bookmark_tab_helper()->ShouldShowBookmarkBar())
       state = BookmarkBar::DETACHED;
     else
       state = BookmarkBar::HIDDEN;
   }
   if (state == bookmark_bar_state_)
     return;
 
   bookmark_bar_state_ = state;
 
@@ skipping 99 matching lines @@
   if (contents && !allow_js_access) {
     contents->web_contents()->GetController().LoadURL(
         target_url,
         content::Referrer(),
         content::PAGE_TRANSITION_LINK,
         std::string());  // No extra headers.
   }
 
   return contents != NULL;
 }