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

chrome/browser/ui/browser.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 64 matching lines @@
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/status_bubble.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/browser/tab_closeable_state_watcher.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tab_menu_model.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_restriction.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 226 matching lines @@
 
 // static
 Browser* Browser::CreateForPopup(Type type,
                                  Profile* profile,
                                  TabContents* new_contents,
                                  const gfx::Rect& initial_bounds) {
   DCHECK(type & TYPE_POPUP);
   Browser* browser = new Browser(type, profile);
   browser->set_override_bounds(initial_bounds);
   browser->CreateBrowserWindow();
-  browser->tabstrip_model()->AppendTabContents(new_contents, true);
+  TabContentsWrapper* wrapper = new TabContentsWrapper(new_contents);
+  browser->tabstrip_model()->AppendTabContents(wrapper, true);
   return browser;
 }
 
 // static
 Browser* Browser::CreateForType(Type type, Profile* profile) {
   Browser* browser = new Browser(type, profile);
   browser->CreateBrowserWindow();
   return browser;
 }
 
@@ skipping 212 matching lines @@
     url = extension->GetFullLaunchURL();
   }
 
   // TODO(erikkay) this can't be correct for extensions
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
   RegisterAppPrefs(app_name);
 
   bool as_panel = extension && (container == extension_misc::LAUNCH_PANEL);
   Browser* browser = Browser::CreateForApp(app_name, extension, profile,
                                            as_panel);
-  TabContents* contents =
+  TabContentsWrapper* wrapper =
       browser->AddSelectedTabWithURL(url, PageTransition::START_PAGE);
+  TabContents* contents = wrapper->tab_contents();
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->render_view_host()->SyncRendererPrefs();
   browser->window()->Show();
 
   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
   //                focus explicitly.
   contents->view()->SetInitialFocus();
 
   if (!as_panel) {
     // Set UPDATE_SHORTCUT as the pending web app action. This action is picked
@@ skipping 36 matching lines @@
 
   // TODO(erikkay): START_PAGE doesn't seem like the right transition in all
   // cases.
   browser::NavigateParams params(browser, extension->GetFullLaunchURL(),
                                  PageTransition::START_PAGE);
   params.tabstrip_add_types = add_type;
 
   // Launch the application in the existing TabContents, if it was supplied.
   if (existing_tab) {
     TabStripModel* model = browser->tabstrip_model();
-    int tab_index = model->GetIndexOfTabContents(existing_tab);
+    int tab_index = model->GetWrapperIndex(existing_tab);
 
     existing_tab->OpenURL(extension->GetFullLaunchURL(), existing_tab->GetURL(),
                           CURRENT_TAB, PageTransition::LINK);
     if (params.tabstrip_add_types & TabStripModel::ADD_PINNED) {
       model->SetTabPinned(tab_index, true);
-      tab_index = model->GetIndexOfTabContents(existing_tab);
+      tab_index = model->GetWrapperIndex(existing_tab);
     }
     if (params.tabstrip_add_types & TabStripModel::ADD_SELECTED)
       model->SelectTabContentsAt(tab_index, true);
 
     contents = existing_tab;
   } else {
     params.disposition = NEW_FOREGROUND_TAB;
     browser::Navigate(&params);
-    contents = params.target_contents;
+    contents = params.target_contents->tab_contents();
   }
 
   if (launch_type == ExtensionPrefs::LAUNCH_FULLSCREEN)
     browser->window()->SetFullscreen(true);
 
   return contents;
 }
 
 // static
 void Browser::OpenBookmarkManagerWindow(Profile* profile) {
@@ skipping 109 matching lines @@
 }
 
 SkBitmap Browser::GetCurrentPageIcon() const {
   TabContents* contents = GetSelectedTabContents();
   // |contents| can be NULL since GetCurrentPageIcon() is called by the window
   // during the window's creation (before tabs have been added).
   return contents ? contents->GetFavIcon() : SkBitmap();
 }
 
 string16 Browser::GetWindowTitleForCurrentTab() const {
-  TabContents* contents =
-      tab_handler_->GetTabStripModel()->GetSelectedTabContents();
+  TabContents* contents = GetSelectedTabContents();
   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 = TabContents::GetDefaultTitle();
@@ skipping 111 matching lines @@
 
 int Browser::selected_index() const {
   return tab_handler_->GetTabStripModel()->selected_index();
 }
 
 int Browser::GetIndexOfController(
     const NavigationController* controller) const {
   return tab_handler_->GetTabStripModel()->GetIndexOfController(controller);
 }
 
-TabContents* Browser::GetTabContentsAt(int index) const {
-  return tab_handler_->GetTabStripModel()->GetTabContentsAt(index);
+TabContentsWrapper* Browser::GetSelectedTabContentsWrapper() const {
+  return tabstrip_model()->GetSelectedTabContents();
+}
+TabContentsWrapper* Browser::GetTabContentsWrapperAt(int index) const {
+  return tabstrip_model()->GetTabContentsAt(index);
 }
 
 TabContents* Browser::GetSelectedTabContents() const {
-  return tab_handler_->GetTabStripModel()->GetSelectedTabContents();
+  TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
+  if (wrapper)
+    return wrapper->tab_contents();
+  return NULL;
+}
+
+TabContents* Browser::GetTabContentsAt(int index) const {
+  TabContentsWrapper* wrapper = tabstrip_model()->GetTabContentsAt(index);
+  if (wrapper)
+    return wrapper->tab_contents();
+  return NULL;
 }
 
 void Browser::SelectTabContentsAt(int index, bool user_gesture) {
   tab_handler_->GetTabStripModel()->SelectTabContentsAt(index, user_gesture);
 }
 
 void Browser::CloseAllTabs() {
   tab_handler_->GetTabStripModel()->CloseAllTabs();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Browser, Tab adding/showing functions:
 
 int Browser::GetIndexForInsertionDuringRestore(int relative_index) {
   return (tab_handler_->GetTabStripModel()->insertion_policy() ==
       TabStripModel::INSERT_AFTER) ? tab_count() : relative_index;
 }
 
-TabContents* Browser::AddSelectedTabWithURL(const GURL& url,
+TabContentsWrapper* Browser::AddSelectedTabWithURL(const GURL& url,
                                             PageTransition::Type transition) {
   browser::NavigateParams params(this, url, transition);
   params.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&params);
   return params.target_contents;
 }
 
-TabContents* Browser::AddTab(TabContents* tab_contents,
+TabContents* Browser::AddTab(TabContentsWrapper* tab_contents,
                              PageTransition::Type type) {
   tab_handler_->GetTabStripModel()->AddTabContents(
       tab_contents, -1, type, TabStripModel::ADD_SELECTED);
-  return tab_contents;
+  return tab_contents->tab_contents();
 }
 
 void Browser::AddTabContents(TabContents* new_contents,
                              WindowOpenDisposition disposition,
                              const gfx::Rect& initial_pos,
                              bool user_gesture) {
   AddNewContents(NULL, new_contents, disposition, initial_pos, user_gesture);
 }
 
 void Browser::CloseTabContents(TabContents* contents) {
@@ skipping 15 matching lines @@
 
 TabContents* 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,
     SessionStorageNamespace* session_storage_namespace) {
-  TabContents* new_tab = new TabContents(
-      profile(), NULL, MSG_ROUTING_NONE,
-      tab_handler_->GetTabStripModel()->GetSelectedTabContents(),
+  TabContentsWrapper* wrapper = TabContentsFactory(profile(), NULL,
+      MSG_ROUTING_NONE,
+      GetSelectedTabContents(),
       session_storage_namespace);
+  TabContents* new_tab = wrapper->tab_contents();
   new_tab->SetExtensionAppById(extension_app_id);
   new_tab->controller().RestoreFromState(navigations, selected_navigation,
                                          from_last_session);
 
   bool really_pin =
       (pin && tab_index == tabstrip_model()->IndexOfFirstNonMiniTab());
   tab_handler_->GetTabStripModel()->InsertTabContentsAt(
-      tab_index, new_tab,
+      tab_index, wrapper,
       select ? TabStripModel::ADD_SELECTED : TabStripModel::ADD_NONE);
   if (really_pin)
     tab_handler_->GetTabStripModel()->SetTabPinned(tab_index, true);
   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->view()->SizeContents(window_->GetRestoredBounds().size());
     new_tab->HideContents();
   }
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service)
       session_service->TabRestored(&new_tab->controller(), really_pin);
   }
   return new_tab;
 }
 
 void Browser::ReplaceRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int selected_navigation,
     bool from_last_session,
     const std::string& extension_app_id,
     SessionStorageNamespace* session_storage_namespace) {
-  TabContents* replacement = new TabContents(profile(), NULL,
+  TabContentsWrapper* wrapper = TabContentsFactory(profile(), NULL,
       MSG_ROUTING_NONE,
-      tab_handler_->GetTabStripModel()->GetSelectedTabContents(),
+      GetSelectedTabContents(),
       session_storage_namespace);
+  TabContents* replacement = wrapper->tab_contents();
   replacement->SetExtensionAppById(extension_app_id);
   replacement->controller().RestoreFromState(navigations, selected_navigation,
                                              from_last_session);
 
   tab_handler_->GetTabStripModel()->ReplaceNavigationControllerAt(
       tab_handler_->GetTabStripModel()->selected_index(),
-      &replacement->controller());
+      wrapper);
 }
 
 bool Browser::CanRestoreTab() {
   return command_updater_.IsCommandEnabled(IDC_RESTORE_TAB);
 }
 
 bool Browser::NavigateToIndexWithDisposition(int index,
                                              WindowOpenDisposition disp) {
   NavigationController& controller =
       GetOrCloneTabForDisposition(disp)->controller();
@@ skipping 69 matching lines @@
 // Browser, Assorted browser commands:
 
 bool Browser::ShouldOpenNewTabForWindowDisposition(
     WindowOpenDisposition disposition) {
   return (disposition == NEW_FOREGROUND_TAB ||
           disposition == NEW_BACKGROUND_TAB);
 }
 
 TabContents* Browser::GetOrCloneTabForDisposition(
        WindowOpenDisposition disposition) {
-  TabContents* current_tab = GetSelectedTabContents();
+  TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   if (ShouldOpenNewTabForWindowDisposition(disposition)) {
     current_tab = current_tab->Clone();
     tab_handler_->GetTabStripModel()->AddTabContents(
         current_tab, -1, PageTransition::LINK,
         disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_SELECTED :
                                             TabStripModel::ADD_NONE);
   }
-  return current_tab;
+  return current_tab->tab_contents();
 }
 
 void Browser::UpdateTabStripModelInsertionPolicy() {
   tab_handler_->GetTabStripModel()->SetInsertionPolicy(UseVerticalTabs() ?
       TabStripModel::INSERT_BEFORE : TabStripModel::INSERT_AFTER);
 }
 
 void Browser::UseVerticalTabsChanged() {
   UpdateTabStripModelInsertionPolicy();
   window()->ToggleTabStripMode();
@@ skipping 42 matching lines @@
       g_browser_process->tab_closeable_state_watcher();
   bool can_close = !watcher || watcher->CanCloseBrowser(this);
   if (!can_close && is_attempting_to_close_browser_)
     CancelWindowClose();
   return can_close;
 }
 
 void Browser::GoBack(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Back"), profile_);
 
-  TabContents* current_tab = GetSelectedTabContents();
+  TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   if (current_tab->controller().CanGoBack()) {
     TabContents* 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->showing_interstitial_page() && (new_tab != current_tab))
+    if (current_tab->tab_contents()->showing_interstitial_page() &&
+        (new_tab != current_tab->tab_contents()))
       return;
     new_tab->controller().GoBack();
   }
 }
 
 void Browser::GoForward(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Forward"), profile_);
-  if (GetSelectedTabContents()->controller().CanGoForward())
+  if (GetSelectedTabContentsWrapper()->controller().CanGoForward())
     GetOrCloneTabForDisposition(disposition)->controller().GoForward();
 }
 
 void Browser::Reload(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Reload"), profile_);
   ReloadInternal(disposition, false);
 }
 
 void Browser::ReloadIgnoringCache(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("ReloadIgnoringCache"), profile_);
   ReloadInternal(disposition, true);
 }
 
 void Browser::ReloadInternal(WindowOpenDisposition disposition,
                              bool ignore_cache) {
   // If we are showing an interstitial, treat this as an OpenURL.
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab && current_tab->showing_interstitial_page()) {
     NavigationEntry* entry = current_tab->controller().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
     OpenURL(entry->url(), GURL(), disposition, PageTransition::RELOAD);
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
-  current_tab = GetOrCloneTabForDisposition(disposition);
-  if (!current_tab->FocusLocationBarByDefault())
-    current_tab->Focus();
+  TabContents* tab = GetOrCloneTabForDisposition(disposition);
+  if (!tab->FocusLocationBarByDefault())
+    tab->Focus();
   if (ignore_cache)
-    current_tab->controller().ReloadIgnoringCache(true);
+    tab->controller().ReloadIgnoringCache(true);
   else
-    current_tab->controller().Reload(true);
+    tab->controller().Reload(true);
 }
 
 void Browser::Home(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Home"), profile_);
   OpenURL(GetHomePage(), GURL(), disposition, PageTransition::AUTO_BOOKMARK);
 }
 
 void Browser::OpenCurrentURL() {
   UserMetrics::RecordAction(UserMetricsAction("LoadURL"), profile_);
   LocationBar* location_bar = window_->GetLocationBar();
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
   if (OpenInstant(open_disposition))
     return;
 
   GURL url(WideToUTF8(location_bar->GetInputString()));
   browser::NavigateParams params(this, url, location_bar->GetPageTransition());
   params.disposition = open_disposition;
   // Use ADD_INHERIT_OPENER so that all pages opened by the omnibox at least
   // inherit the opener. In some cases the tabstrip will determine the group
   // should be inherited, in which case the group is inherited instead of the
   // opener.
   params.tabstrip_add_types =
       TabStripModel::ADD_FORCE_INDEX | TabStripModel::ADD_INHERIT_OPENER;
   browser::Navigate(&params);
 }
 
 void Browser::Stop() {
   UserMetrics::RecordAction(UserMetricsAction("Stop"), profile_);
-  GetSelectedTabContents()->Stop();
+  GetSelectedTabContentsWrapper()->tab_contents()->Stop();
 }
 
 void Browser::NewWindow() {
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kIncognito)) {
     NewIncognitoWindow();
     return;
   }
   UserMetrics::RecordAction(UserMetricsAction("NewWindow"), profile_);
   SessionService* session_service =
@@ skipping 19 matching lines @@
 
   if (type() == TYPE_NORMAL) {
     AddBlankTab(true);
   } else {
     Browser* b = GetOrCreateTabbedBrowser(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->GetSelectedTabContents()->view()->RestoreFocus();
+    b->GetSelectedTabContentsWrapper()->view()->RestoreFocus();
   }
 }
 
 void Browser::CloseTab() {
   UserMetrics::RecordAction(UserMetricsAction("CloseTab_Accelerator"),
                             profile_);
   if (CanCloseTab()) {
     tab_handler_->GetTabStripModel()->CloseTabContentsAt(
         tab_handler_->GetTabStripModel()->selected_index(),
         TabStripModel::CLOSE_USER_GESTURE |
@@ skipping 73 matching lines @@
 
   chrome_browser_net::WriteURLToClipboard(
       contents->GetURL(),
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void Browser::ConvertPopupToTabbedBrowser() {
   UserMetrics::RecordAction(UserMetricsAction("ShowAsTab"), profile_);
   int tab_strip_index = tab_handler_->GetTabStripModel()->selected_index();
-  TabContents* contents =
+  TabContentsWrapper* contents =
       tab_handler_->GetTabStripModel()->DetachTabContentsAt(tab_strip_index);
   Browser* browser = Browser::Create(profile_);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 void Browser::ToggleFullscreenMode() {
 #if !defined(OS_MACOSX)
   // In kiosk mode, we always want to be fullscreen. When the browser first
   // starts we're not yet fullscreen, so let the initial toggle go through.
@@ skipping 175 matching lines @@
 
 void Browser::Zoom(PageZoom::Function zoom_function) {
   static const UserMetricsAction kActions[] = {
                       UserMetricsAction("ZoomMinus"),
                       UserMetricsAction("ZoomNormal"),
                       UserMetricsAction("ZoomPlus")
                       };
 
   UserMetrics::RecordAction(kActions[zoom_function - PageZoom::ZOOM_OUT],
                             profile_);
-  TabContents* tab_contents = GetSelectedTabContents();
+  TabContentsWrapper* tab_contents = GetSelectedTabContentsWrapper();
   tab_contents->render_view_host()->Zoom(zoom_function);
 }
 
 void Browser::FocusToolbar() {
   UserMetrics::RecordAction(UserMetricsAction("FocusToolbar"), profile_);
   window_->FocusToolbar();
 }
 
 void Browser::FocusAppMenu() {
   UserMetrics::RecordAction(UserMetricsAction("FocusAppMenu"), profile_);
@@ skipping 50 matching lines @@
   select_file_dialog_->SelectFile(SelectFileDialog::SELECT_OPEN_FILE,
                                   string16(), directory,
                                   NULL, 0, FILE_PATH_LITERAL(""),
                                   parent_window, NULL);
 #endif
 }
 
 void Browser::OpenCreateShortcutsDialog() {
   UserMetrics::RecordAction(UserMetricsAction("CreateShortcut"), profile_);
 #if defined(OS_WIN) || defined(OS_LINUX)
-  TabContents* current_tab = GetSelectedTabContents();
-  DCHECK(current_tab && web_app::IsValidUrl(current_tab->GetURL())) <<
-      "Menu item should be disabled.";
+  TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
+  DCHECK(current_tab &&
+      web_app::IsValidUrl(current_tab->tab_contents()->GetURL())) <<
+          "Menu item should be disabled.";
 
   NavigationEntry* entry = current_tab->controller().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
@@ skipping 11 matching lines @@
       uma_string = "DevTools_ToggleConsole";
       break;
     case DEVTOOLS_TOGGLE_ACTION_NONE:
     case DEVTOOLS_TOGGLE_ACTION_INSPECT:
     default:
       uma_string = "DevTools_ToggleWindow";
       break;
   }
   UserMetrics::RecordAction(UserMetricsAction(uma_string.c_str()), profile_);
   DevToolsManager::GetInstance()->ToggleDevToolsWindow(
-      GetSelectedTabContents()->render_view_host(), action);
+      GetSelectedTabContentsWrapper()->render_view_host(), action);
 }
 
 void Browser::OpenTaskManager() {
   UserMetrics::RecordAction(UserMetricsAction("TaskManager"), profile_);
   window_->ShowTaskManager();
 }
 
 void Browser::OpenBugReportDialog() {
   UserMetrics::RecordAction(UserMetricsAction("ReportBug"), profile_);
   window_->ShowReportBugDialog();
@@ skipping 53 matching lines @@
       ReplaceStringPlaceholders(kBrokenPageUrl, subst, NULL);
   ShowSingletonTab(GURL(report_page_url));
 }
 
 void Browser::ShowOptionsTab(const std::string& sub_page) {
   GURL url(chrome::kChromeUISettingsURL + sub_page);
 
   // See if there is already an options tab open that we can use.
   TabStripModel* model = tab_handler_->GetTabStripModel();
   for (int i = 0; i < model->count(); i++) {
-    TabContents* tc = model->GetTabContentsAt(i);
-    const GURL& tab_url = tc->GetURL();
+    TabContentsWrapper* tc = model->GetTabContentsAt(i);
+    const GURL& tab_url = tc->tab_contents()->GetURL();
 
     if (tab_url.scheme() == url.scheme() && tab_url.host() == url.host()) {
       // We found an existing options tab, load the URL in this tab.  (Note:
       // this may cause us to unnecessarily reload the same page.  We can't
       // really detect that unless the options page is permitted to change the
       // URL in the address bar, but security policy doesn't allow that.
       browser::NavigateParams params(this, url, PageTransition::GENERATED);
       params.source_contents = tc;
       browser::Navigate(&params);
       model->SelectTabContentsAt(i, false);
@@ skipping 276 matching lines @@
 
 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 (!GetSelectedTabContents())
+  if (!GetSelectedTabContentsWrapper())
     return;
 
   DCHECK(command_updater_.IsCommandEnabled(id)) << "Invalid/disabled command";
 
   // 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);
     last_blocked_command_id_ = id;
@@ skipping 184 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(TabContents* contents,
+void Browser::UpdateUIForNavigationInTab(TabContentsWrapper* contents,
                                          PageTransition::Type transition,
                                          bool user_initiated) {
   tabstrip_model()->TabNavigating(contents, transition);
 
-  bool contents_is_selected = contents == GetSelectedTabContents();
+  bool contents_is_selected = contents == GetSelectedTabContentsWrapper();
   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, TabContents::INVALIDATE_URL);
+  ScheduleUIUpdate(contents->tab_contents(), TabContents::INVALIDATE_URL);
 
   if (contents_is_selected)
-    contents->Focus();
+    contents->tab_contents()->Focus();
 }
 
 GURL Browser::GetHomePage() const {
   // --homepage overrides any preferences.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kHomePage)) {
     // TODO(evanm): clean up usage of DIR_CURRENT.
     //   http://code.google.com/p/chromium/issues/detail?id=60630
     // For now, allow this code to call getcwd().
     base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ skipping 39 matching lines @@
   return profile();
 }
 
 Browser* Browser::AsBrowser() {
   return this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelDelegate implementation:
 
-TabContents* Browser::AddBlankTab(bool foreground) {
+TabContentsWrapper* Browser::AddBlankTab(bool foreground) {
   return AddBlankTabAt(-1, foreground);
 }
 
-TabContents* Browser::AddBlankTabAt(int index, bool foreground) {
+TabContentsWrapper* Browser::AddBlankTabAt(int index, bool foreground) {
   // Time new tab page creation time.  We keep track of the timing data in
   // TabContents, but we want to include the time it takes to create the
   // TabContents object too.
   base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
   browser::NavigateParams params(this, GURL(chrome::kChromeUINewTabURL),
                                  PageTransition::TYPED);
   params.disposition = foreground ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   params.tabstrip_index = index;
   browser::Navigate(&params);
-  params.target_contents->set_new_tab_start_time(new_tab_start_time);
+  params.target_contents->tab_contents()->set_new_tab_start_time(
+      new_tab_start_time);
   return params.target_contents;
 }
 
-Browser* Browser::CreateNewStripWithContents(TabContents* detached_contents,
-                                             const gfx::Rect& window_bounds,
-                                             const DockInfo& dock_info,
-                                             bool maximize) {
+Browser* Browser::CreateNewStripWithContents(
+    TabContentsWrapper* 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_NORMAL, profile_);
   browser->set_override_bounds(new_window_bounds);
   browser->set_maximized_state(
       maximize ? MAXIMIZED_STATE_MAXIMIZED : MAXIMIZED_STATE_UNMAXIMIZED);
   browser->CreateBrowserWindow();
   browser->tabstrip_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);
+  browser->LoadingStateChanged(detached_contents->tab_contents());
   return browser;
 }
 
-void Browser::ContinueDraggingDetachedTab(TabContents* contents,
+void Browser::ContinueDraggingDetachedTab(TabContentsWrapper* contents,
                                           const gfx::Rect& window_bounds,
                                           const gfx::Rect& tab_bounds) {
   Browser* browser = new Browser(TYPE_NORMAL, profile_);
   browser->set_override_bounds(window_bounds);
   browser->CreateBrowserWindow();
   browser->tabstrip_model()->AppendTabContents(contents, true);
-  browser->LoadingStateChanged(contents);
+  browser->LoadingStateChanged(contents->tab_contents());
   browser->window()->Show();
   browser->window()->ContinueDraggingDetachedTab(tab_bounds);
 }
 
 int Browser::GetDragActions() const {
   return TabStripModelDelegate::TAB_TEAROFF_ACTION | (tab_count() > 1 ?
       TabStripModelDelegate::TAB_MOVE_ACTION : 0);
 }
 
-TabContents* Browser::CreateTabContentsForURL(
+TabContentsWrapper* Browser::CreateTabContentsForURL(
     const GURL& url, const GURL& referrer, Profile* profile,
     PageTransition::Type transition, bool defer_load,
     SiteInstance* instance) const {
-  TabContents* contents = new TabContents(profile, instance,
+  TabContentsWrapper* contents = TabContentsFactory(profile, instance,
       MSG_ROUTING_NONE,
-      tab_handler_->GetTabStripModel()->GetSelectedTabContents(), NULL);
-
+      GetSelectedTabContents(), 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->controller().LoadURL(url, referrer, transition);
   }
 
   return contents;
 }
 
 bool Browser::CanDuplicateContentsAt(int index) {
   NavigationController& nc = GetTabContentsAt(index)->controller();
   return nc.tab_contents() && nc.GetLastCommittedEntry();
 }
 
 void Browser::DuplicateContentsAt(int index) {
-  TabContents* contents = GetTabContentsAt(index);
+  TabContentsWrapper* contents = GetTabContentsWrapperAt(index);
   TabContents* new_contents = NULL;
   DCHECK(contents);
   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.
-    new_contents = contents->Clone();
+    TabContentsWrapper* wrapper = contents->Clone();
+    new_contents = wrapper->tab_contents();
     pinned = tab_handler_->GetTabStripModel()->IsTabPinned(index);
     int add_types = TabStripModel::ADD_SELECTED |
         TabStripModel::ADD_INHERIT_GROUP |
         (pinned ? TabStripModel::ADD_PINNED : 0);
     tab_handler_->GetTabStripModel()->InsertTabContentsAt(index + 1,
-                                                          new_contents,
+                                                          wrapper,
                                                           add_types);
   } else {
     Browser* browser = NULL;
     if (type_ & TYPE_APP) {
       DCHECK((type_ & TYPE_POPUP) == 0);
       DCHECK(type_ != TYPE_APP_PANEL);
       browser = Browser::CreateForApp(app_name_, extension_app_, profile_,
                                       false);
     } else if (type_ == TYPE_POPUP) {
       browser = Browser::CreateForType(TYPE_POPUP, profile_);
     }
 
     // Preserve the size of the original window. The new window has already
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
-    new_contents = browser->AddTab(
-        contents->Clone()->controller().tab_contents(),
-        PageTransition::LINK);
+    new_contents = browser->AddTab(contents->Clone(), PageTransition::LINK);
   }
 
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service)
       session_service->TabRestored(&new_contents->controller(), pinned);
   }
 }
 
 void Browser::CloseFrameAfterDragSession() {
 #if defined(OS_WIN) || defined(OS_LINUX)
   // 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, method_factory_.NewRunnableMethod(&Browser::CloseFrame));
 #endif
 }
 
-void Browser::CreateHistoricalTab(TabContents* contents) {
+void Browser::CreateHistoricalTab(TabContentsWrapper* contents) {
   // We don't create historical tabs for incognito windows or windows without
   // profiles.
   if (!profile() || profile()->IsOffTheRecord() ||
       !profile()->GetTabRestoreService()) {
     return;
   }
 
   // We only create historical tab entries for tabbed browser windows.
   if (CanSupportWindowFeature(FEATURE_TABSTRIP)) {
     profile()->GetTabRestoreService()->CreateHistoricalTab(
         &contents->controller());
   }
 }
 
-bool Browser::RunUnloadListenerBeforeClosing(TabContents* contents) {
-  return Browser::RunUnloadEventsHelper(contents);
+bool Browser::RunUnloadListenerBeforeClosing(TabContentsWrapper* contents) {
+  return Browser::RunUnloadEventsHelper(contents->tab_contents());
 }
 
 bool Browser::CanReloadContents(TabContents* source) const {
   return type() != TYPE_DEVTOOLS;
 }
 
 bool Browser::CanCloseContentsAt(int index) {
   if (!CanCloseTab())
     return false;
   if (tab_handler_->GetTabStripModel()->count() > 1)
@@ skipping 38 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 TYPE_EXTENSION_APP != type();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelObserver implementation:
 
-void Browser::TabInsertedAt(TabContents* contents,
+void Browser::TabInsertedAt(TabContentsWrapper* contents,
                             int index,
                             bool foreground) {
-  contents->set_delegate(this);
+  contents->tab_contents()->set_delegate(this);
   contents->controller().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);
+  LoadingStateChanged(contents->tab_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, NotificationType::TAB_CONTENTS_DISCONNECTED,
-                 Source<TabContents>(contents));
+                 Source<TabContentsWrapper>(contents));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
-                           TabContents* contents,
+                           TabContentsWrapper* contents,
                            int index) {
   NotificationService::current()->Notify(
       NotificationType::TAB_CLOSING,
       Source<NavigationController>(&contents->controller()),
       NotificationService::NoDetails());
 
   // Sever the TabContents' connection back to us.
-  contents->set_delegate(NULL);
+  contents->tab_contents()->set_delegate(NULL);
 }
 
-void Browser::TabDetachedAt(TabContents* contents, int index) {
+void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
 
-void Browser::TabDeselectedAt(TabContents* contents, int index) {
+void Browser::TabDeselectedAt(TabContentsWrapper* contents, int index) {
   if (instant())
     instant()->DestroyPreviewContents();
 
   // Save what the user's currently typing, so it can be restored when we
   // switch back to this tab.
-  window_->GetLocationBar()->SaveStateToContents(contents);
+  window_->GetLocationBar()->SaveStateToContents(contents->tab_contents());
 }
 
-void Browser::TabSelectedAt(TabContents* old_contents,
-                            TabContents* new_contents,
+void Browser::TabSelectedAt(TabContentsWrapper* old_contents,
+                            TabContentsWrapper* new_contents,
                             int index,
                             bool user_gesture) {
   DCHECK(old_contents != new_contents);
 
   // If we have any update pending, do it now.
   if (!chrome_updater_factory_.empty() && old_contents)
     ProcessPendingUIUpdates();
 
   // Propagate the profile to the location bar.
   UpdateToolbar(true);
 
   // Update reload/stop state.
-  UpdateReloadStopState(new_contents->is_loading(), true);
+  UpdateReloadStopState(new_contents->tab_contents()->is_loading(), true);
 
   // 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(WideToUTF16Hack(
         GetSelectedTabContents()->GetStatusText()));
   }
 
   if (HasFindBarController()) {
-    find_bar_controller_->ChangeTabContents(new_contents);
+    find_bar_controller_->ChangeTabContents(new_contents->tab_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.
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service && !tab_handler_->GetTabStripModel()->closing_all()) {
       session_service->SetSelectedTabInWindow(
           session_id(), tab_handler_->GetTabStripModel()->selected_index());
     }
   }
 }
 
-void Browser::TabMoved(TabContents* contents,
+void Browser::TabMoved(TabContentsWrapper* 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(TabContents* old_contents,
-                            TabContents* new_contents,
+void Browser::TabReplacedAt(TabContentsWrapper* old_contents,
+                            TabContentsWrapper* new_contents,
                             int index) {
   TabDetachedAtImpl(old_contents, index, DETACH_TYPE_REPLACE);
   TabInsertedAt(new_contents, index,
                 (index == tab_handler_->GetTabStripModel()->selected_index()));
 
   int entry_count = new_contents->controller().entry_count();
   if (entry_count > 0) {
     // Send out notification so that observers are updated appropriately.
     new_contents->controller().NotifyEntryChanged(
         new_contents->controller().GetEntryAtIndex(entry_count - 1),
         entry_count - 1);
   }
 
   SessionService* session_service = profile()->GetSessionService();
   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->controller(),
         tab_handler_->GetTabStripModel()->IsTabPinned(index));
   }
 }
 
-void Browser::TabPinnedStateChanged(TabContents* contents, int index) {
+void Browser::TabPinnedStateChanged(TabContentsWrapper* contents, int index) {
   if (!profile()->HasSessionService())
     return;
   SessionService* session_service = profile()->GetSessionService();
   if (session_service) {
     session_service->SetPinnedState(
         session_id(),
         GetTabContentsAt(index)->controller().session_id(),
         tab_handler_->GetTabStripModel()->IsTabPinned(index));
   }
 }
@@ skipping 13 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabContentsDelegate implementation:
 
 void Browser::OpenURLFromTab(TabContents* source,
                              const GURL& url,
                              const GURL& referrer,
                              WindowOpenDisposition disposition,
                              PageTransition::Type transition) {
   browser::NavigateParams params(this, url, transition);
-  params.source_contents = source;
+  params.source_contents =
+    tabstrip_model()->GetTabContentsAt(
+      tabstrip_model()->GetWrapperIndex(source));
   params.referrer = referrer;
   params.disposition = disposition;
   params.tabstrip_add_types = TabStripModel::ADD_NONE;
   browser::Navigate(&params);
 }
 
 void Browser::NavigationStateChanged(const TabContents* source,
                                      unsigned changed_flags) {
   // Only update the UI when something visible has changed.
   if (changed_flags)
@@ skipping 26 matching lines @@
     GdkScreen* screen = gdk_screen_get_default();
     int max_width = gdk_screen_get_width(screen) * kPopupMaxWidthFactor;
     int max_height = gdk_screen_get_height(screen) * kPopupMaxHeightFactor;
     if (initial_pos.width() > max_width || initial_pos.width() == 0 ||
         initial_pos.height() > max_height || initial_pos.height() == 0) {
       disposition = NEW_FOREGROUND_TAB;
     }
   }
 #endif
 
-    browser::NavigateParams params(this, new_contents);
-    params.source_contents = source;
-    params.disposition = disposition;
-    params.window_bounds = initial_pos;
-    browser::Navigate(&params);
+  TabContentsWrapper* wrapper = new TabContentsWrapper(new_contents);
+  browser::NavigateParams params(this, wrapper);
+  params.source_contents =
+      tabstrip_model()->GetTabContentsAt(
+          tabstrip_model()->GetWrapperIndex(source));
+  params.disposition = disposition;
+  params.window_bounds = initial_pos;
+  browser::Navigate(&params);
 }
 
 void Browser::ActivateContents(TabContents* contents) {
   tab_handler_->GetTabStripModel()->SelectTabContentsAt(
-      tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents), false);
+      tab_handler_->GetTabStripModel()->GetWrapperIndex(contents), false);
   window_->Activate();
 }
 
 void Browser::DeactivateContents(TabContents* contents) {
   window_->Deactivate();
 }
 
 void Browser::LoadingStateChanged(TabContents* source) {
   window_->UpdateLoadingAnimations(
       tab_handler_->GetTabStripModel()->TabsAreLoading());
   window_->UpdateTitleBar();
 
-  if (source == GetSelectedTabContents()) {
+  TabContents* selected_contents = GetSelectedTabContents();
+  if (source == selected_contents) {
     UpdateReloadStopState(source->is_loading(), false);
     if (GetStatusBubble()) {
       GetStatusBubble()->SetStatus(WideToUTF16(
           GetSelectedTabContents()->GetStatusText()));
     }
 
     if (!source->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
@@ skipping 12 matching lines @@
 void Browser::CloseContents(TabContents* source) {
   if (is_attempting_to_close_browser_) {
     // If we're trying to close the browser, just clear the state related to
     // waiting for unload to fire. Don't actually try to close the tab as it
     // will go down the slow shutdown path instead of the fast path of killing
     // all the renderer processes.
     ClearUnloadState(source);
     return;
   }
 
-  int index = tab_handler_->GetTabStripModel()->GetIndexOfTabContents(source);
+  int index = tab_handler_->GetTabStripModel()->GetWrapperIndex(source);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED() << "CloseContents called for tab not in our strip";
     return;
   }
   tab_handler_->GetTabStripModel()->CloseTabContentsAt(
       index,
       TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 }
 
 void Browser::MoveContents(TabContents* source, const gfx::Rect& pos) {
   if ((type() & TYPE_POPUP) == 0) {
     NOTREACHED() << "moving invalid browser type";
     return;
   }
   window_->SetBounds(pos);
 }
 
 void Browser::DetachContents(TabContents* source) {
-  int index = tab_handler_->GetTabStripModel()->GetIndexOfTabContents(source);
+  int index = tab_handler_->GetTabStripModel()->GetWrapperIndex(source);
   if (index >= 0)
     tab_handler_->GetTabStripModel()->DetachTabContentsAt(index);
 }
 
 bool Browser::IsPopup(const TabContents* source) const {
   // A non-tabbed BROWSER is an unconstrained popup.
   return !!(type() & TYPE_POPUP);
 }
 
 void Browser::ToolbarSizeChanged(TabContents* source, bool is_animating) {
@@ skipping 43 matching lines @@
 void Browser::ContentsZoomChange(bool zoom_in) {
   ExecuteCommand(zoom_in ? IDC_ZOOM_PLUS : IDC_ZOOM_MINUS);
 }
 
 void Browser::OnContentSettingsChange(TabContents* source) {
   if (source == GetSelectedTabContents())
     window_->GetLocationBar()->UpdateContentSettingsIcons();
 }
 
 void Browser::SetTabContentBlocked(TabContents* contents, bool blocked) {
-  int index = tabstrip_model()->GetIndexOfTabContents(contents);
+  int index = tabstrip_model()->GetWrapperIndex(contents);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED();
     return;
   }
   tabstrip_model()->SetTabBlocked(index, blocked);
 }
 
 void Browser::TabContentsFocused(TabContents* tab_content) {
   window_->TabContentsFocused(tab_content);
 }
@@ skipping 10 matching lines @@
   return (type_ & TYPE_APP) != 0;
 }
 
 void Browser::ConvertContentsToApplication(TabContents* contents) {
   const GURL& url = contents->controller().GetActiveEntry()->url();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
   RegisterAppPrefs(app_name);
 
   DetachContents(contents);
   Browser* browser = Browser::CreateForApp(app_name, NULL, profile_, false);
-  browser->tabstrip_model()->AppendTabContents(contents, true);
-  TabContents* tab_contents = browser->GetSelectedTabContents();
+  TabContentsWrapper* wrapper = new TabContentsWrapper(contents);
+  browser->tabstrip_model()->AppendTabContents(wrapper, true);
+  TabContents* tab_contents = GetSelectedTabContents();
   tab_contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   tab_contents->render_view_host()->SyncRendererPrefs();
   browser->window()->Show();
 }
 
 bool Browser::ShouldDisplayURLField() {
   return !IsApplication();
 }
 
 void Browser::BeforeUnloadFired(TabContents* tab,
@@ skipping 243 matching lines @@
     }
 
     case NotificationType::EXTENSION_UNLOADED:
     case NotificationType::EXTENSION_UNLOADED_DISABLED: {
       window()->GetLocationBar()->UpdatePageActions();
 
       // Close any tabs from the unloaded extension.
       const Extension* extension = Details<const Extension>(details).ptr();
       TabStripModel* model = tab_handler_->GetTabStripModel();
       for (int i = model->count() - 1; i >= 0; --i) {
-        TabContents* tc = model->GetTabContentsAt(i);
+        TabContents* tc = model->GetTabContentsAt(i)->tab_contents();
         if (tc->GetURL().SchemeIs(chrome::kExtensionScheme) &&
             tc->GetURL().host() == extension->id()) {
           CloseTabContents(tc);
         }
       }
 
       break;
     }
 
     case NotificationType::EXTENSION_PROCESS_TERMINATED: {
@@ skipping 109 matching lines @@
       show_main_ui && profile_->IsSyncAccessible());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, InstantDelegate implementation:
 
 void Browser::PrepareForInstant() {
   window_->PrepareForInstant();
 }
 
-void Browser::ShowInstant(TabContents* preview_contents) {
-  DCHECK(instant_->tab_contents() == GetSelectedTabContents());
-  window_->ShowInstant(preview_contents);
+void Browser::ShowInstant(TabContentsWrapper* preview_contents) {
+  DCHECK(instant_->tab_contents() == GetSelectedTabContentsWrapper());
+  window_->ShowInstant(preview_contents->tab_contents());
 }
 
 void Browser::HideInstant() {
   window_->HideInstant();
 }
 
-void Browser::CommitInstant(TabContents* preview_contents) {
-  TabContents* tab_contents = instant_->tab_contents();
-  int index = tab_handler_->GetTabStripModel()->GetIndexOfTabContents(
-      tab_contents);
-  DCHECK_NE(-1, index);
+void Browser::CommitInstant(TabContentsWrapper* preview_contents) {
+  TabContentsWrapper* tab_contents = instant_->tab_contents();
+  int index =
+      tab_handler_->GetTabStripModel()->GetIndexOfTabContents(tab_contents);
+  DCHECK_NE(TabStripModel::kNoTab, index);
   preview_contents->controller().CopyStateFromAndPrune(
       &tab_contents->controller());
   // TabStripModel takes ownership of preview_contents.
   tab_handler_->GetTabStripModel()->ReplaceTabContentsAt(
       index, preview_contents);
 }
 
 void Browser::SetSuggestedText(const string16& text) {
   window()->GetLocationBar()->SetSuggestedText(text);
 }
@@ skipping 254 matching lines @@
   command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_CONSOLE,
                                         dev_tools_enabled);
   command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_INSPECT,
                                         dev_tools_enabled);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, UI update coalescing and handling (private):
 
 void Browser::UpdateToolbar(bool should_restore_state) {
-  window_->UpdateToolbar(GetSelectedTabContents(), should_restore_state);
+  window_->UpdateToolbar(GetSelectedTabContentsWrapper(), should_restore_state);
 }
 
 void Browser::ScheduleUIUpdate(const TabContents* source,
                                unsigned changed_flags) {
   if (!source)
     return;
 
   // Do some synchronous updates.
   if (changed_flags & TabContents::INVALIDATE_URL &&
       source == GetSelectedTabContents()) {
@@ skipping 93 matching lines @@
         command_updater_.UpdateCommandEnabled(IDC_CREATE_SHORTCUTS,
             web_app::IsValidUrl(contents->GetURL()));
 #endif
         window_->UpdateTitleBar();
       }
     }
 
     // Updates that don't depend upon the selected state go here.
     if (flags & (TabContents::INVALIDATE_TAB | TabContents::INVALIDATE_TITLE)) {
       tab_handler_->GetTabStripModel()->UpdateTabContentsStateAt(
-          tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents),
+          tab_handler_->GetTabStripModel()->GetWrapperIndex(contents),
           TabStripModelObserver::ALL);
     }
 
     // We don't need to process INVALIDATE_STATE, since that's not visible.
   }
 
   scheduled_updates_.clear();
 }
 
 void Browser::RemoveScheduledUpdatesFor(TabContents* contents) {
@@ skipping 247 matching lines @@
     GetSelectedTabContents()->StartFinding(find_text,
                                            forward_direction,
                                            false);  // Not case sensitive.
   }
 }
 
 void Browser::CloseFrame() {
   window_->Close();
 }
 
-void Browser::TabDetachedAtImpl(TabContents* contents, int index,
+void Browser::TabDetachedAtImpl(TabContentsWrapper* 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 == GetSelectedTabContents())
-      window_->GetLocationBar()->SaveStateToContents(contents);
+      window_->GetLocationBar()->SaveStateToContents(contents->tab_contents());
 
     if (!tab_handler_->GetTabStripModel()->closing_all())
       SyncHistoryWithTabs(0);
   }
 
-  contents->set_delegate(NULL);
-  RemoveScheduledUpdatesFor(contents);
+  contents->tab_contents()->set_delegate(NULL);
+  RemoveScheduledUpdatesFor(contents->tab_contents());
 
   if (find_bar_controller_.get() &&
       index == tab_handler_->GetTabStripModel()->selected_index()) {
     find_bar_controller_->ChangeTabContents(NULL);
   }
 
   registrar_.Remove(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
-                    Source<TabContents>(contents));
+                    Source<TabContentsWrapper>(contents));
 }
 
 // static
 void Browser::RegisterAppPrefs(const std::string& app_name) {
   // A set of apps that we've already started.
   static std::set<std::string>* g_app_names = NULL;
 
   if (!g_app_names)
     g_app_names = new std::set<std::string>;
 
@@ skipping 19 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 TabContents, configuring and installing
+// all its supporting objects and observers.
+TabContentsWrapper* Browser::TabContentsFactory(
+    Profile* profile,
+    SiteInstance* site_instance,
+    int routing_id,
+    const TabContents* base_tab_contents,
+    SessionStorageNamespace* session_storage_namespace) {
+  TabContents* new_contents = new TabContents(profile, site_instance,
+                                              routing_id, base_tab_contents,
+                                              session_storage_namespace);
+  TabContentsWrapper* wrapper = new TabContentsWrapper(new_contents);
+  return wrapper;
+}
+
 bool Browser::OpenInstant(WindowOpenDisposition disposition) {
   if (!instant() || !instant()->is_active() || !instant()->IsCurrent())
     return false;
 
   if (disposition == CURRENT_TAB) {
     instant()->CommitCurrentPreview(INSTANT_COMMIT_PRESSED_ENTER);
     return true;
   }
   if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB) {
     HideInstant();
-    TabContents* preview_contents = instant()->ReleasePreviewContents(
+    TabContentsWrapper* preview_contents = instant()->ReleasePreviewContents(
         INSTANT_COMMIT_PRESSED_ENTER);
     preview_contents->controller().PruneAllButActive();
     tab_handler_->GetTabStripModel()->AddTabContents(
         preview_contents,
         -1,
         instant()->last_transition_type(),
         disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_SELECTED :
                                             TabStripModel::ADD_NONE);
-    instant()->CompleteRelease(preview_contents);
+    instant()->CompleteRelease(preview_contents->tab_contents());
     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 (type() == TYPE_NORMAL && InstantController::IsEnabled(profile()) &&
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(profile_, this));
   }
 }