Replace most of Browser::GetSelectedTabContents calls into Browser::GetSelectedWebContents. I've ...

chrome/browser/ui/browser.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 955 matching lines @@
 }
 
 SkBitmap Browser::GetCurrentPageIcon() const {
   TabContentsWrapper* contents = GetSelectedTabContentsWrapper();
   // |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 {
-  TabContents* contents = GetSelectedTabContents();
+  WebContents* contents = GetSelectedWebContents();
   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 86 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.
-  TabContents* contents = GetSelectedTabContents();
+  WebContents* contents = GetSelectedWebContents();
   if (contents && contents->GetCrashedStatus() ==
      base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kReloadKilledTabs)) {
       Reload(CURRENT_TAB);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 86 matching lines @@
 
 int Browser::GetIndexOfController(
     const NavigationController* controller) const {
   return tab_handler_->GetTabStripModel()->GetIndexOfController(controller);
 }
 
 TabContentsWrapper* Browser::GetSelectedTabContentsWrapper() const {
   return tabstrip_model()->GetActiveTabContents();
 }
 
+WebContents* Browser::GetSelectedWebContents() const {
+  TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
+  return wrapper ? wrapper->web_contents() : NULL;
+}
+
 TabContentsWrapper* Browser::GetTabContentsWrapperAt(int index) const {
   return tabstrip_model()->GetTabContentsAt(index);
 }
 
 TabContents* Browser::GetSelectedTabContents() const {
   TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
   if (wrapper)
     return wrapper->tab_contents();
   return NULL;
 }
@@ skipping 200 matching lines @@
 
 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);
-  TabContents* contents = GetSelectedTabContents();
+  WebContents* contents = GetSelectedWebContents();
   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 119 matching lines @@
 }
 
 void Browser::ReloadIgnoringCache(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("ReloadIgnoringCache"));
   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();
+  WebContents* current_tab = GetSelectedWebContents();
   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.
@@ skipping 24 matching lines @@
 
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
   if (OpenInstant(open_disposition))
     return;
 
   GURL url(location_bar->GetInputString());
 
   if (open_disposition == CURRENT_TAB && TabFinder::IsEnabled()) {
     Browser* existing_browser = NULL;
-    TabContents* existing_tab = TabFinder::GetInstance()->FindTab(
+    WebContents* existing_tab = TabFinder::GetInstance()->FindTab(
         this, url, &existing_browser);
     if (existing_tab) {
       existing_browser->ActivateContents(existing_tab);
       return;
     }
   }
 
   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
@@ skipping 134 matching lines @@
     return;
 
   service->RestoreMostRecentEntry(tab_restore_service_delegate());
 }
 
 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.
 
-  TabContents* contents = GetSelectedTabContents();
+  WebContents* contents = GetSelectedWebContents();
   if (!toolbar_model_.ShouldDisplayURL())
     return;
 
   chrome_browser_net::WriteURLToClipboard(
       contents->GetURL(),
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void Browser::ConvertPopupToTabbedBrowser() {
@@ skipping 23 matching lines @@
   if (window_->IsFullscreen()) {
     ToggleFullscreenMode(false);
     // ToggleFullscreenMode is asynchronous, so we don't have omnibox
     // visible at this point. Wait for next event cycle which toggles
     // the visibility of omnibox before creating new tab.
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&Browser::Search, weak_factory_.GetWeakPtr()));
     return;
   }
 
-  const GURL& url = GetSelectedTabContents()->GetURL();
+  const GURL& url = GetSelectedWebContents()->GetURL();
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() == chrome::kChromeUINewTabHost) {
     // If the NTP is showing, focus the omnibox.
     window_->SetFocusToLocationBar(true);
   } else {
     // Otherwise, open the NTP.
     NewTab();
   }
 }
 
@@ skipping 29 matching lines @@
   // 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 were the bubble is deleted as soon as it is shown.
     window_->ShowBookmarkBubble(url, was_bookmarked);
   }
 }
 
 void Browser::SavePage() {
   content::RecordAction(UserMetricsAction("SavePage"));
-  TabContents* current_tab = GetSelectedTabContents();
+  WebContents* current_tab = GetSelectedWebContents();
   if (current_tab && current_tab->GetContentsMimeType() == "application/pdf")
     content::RecordAction(UserMetricsAction("PDF.SavePage"));
-  GetSelectedTabContents()->OnSavePage();
+  GetSelectedWebContents()->OnSavePage();
 }
 
 void Browser::ViewSelectedSource() {
   ViewSource(GetSelectedTabContentsWrapper());
 }
 
 void Browser::ShowFindBar() {
   GetFindBarController()->Show();
 }
 
 bool Browser::SupportsWindowFeature(WindowFeature feature) const {
   return SupportsWindowFeatureImpl(feature, true);
 }
 
 bool Browser::CanSupportWindowFeature(WindowFeature feature) const {
   return SupportsWindowFeatureImpl(feature, false);
 }
 
 void Browser::EmailPageLocation() {
   content::RecordAction(UserMetricsAction("EmailPageLocation"));
-  TabContents* tc = GetSelectedTabContents();
-  DCHECK(tc);
+  WebContents* wc = GetSelectedWebContents();
+  DCHECK(wc);
 
   std::string title = net::EscapeQueryParamValue(
-      UTF16ToUTF8(tc->GetTitle()), false);
-  std::string page_url = net::EscapeQueryParamValue(tc->GetURL().spec(), false);
+      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::Print() {
   if (switches::IsPrintPreviewEnabled())
     GetSelectedTabContentsWrapper()->print_view_manager()->PrintPreviewNow();
   else
     GetSelectedTabContentsWrapper()->print_view_manager()->PrintNow();
 }
 
 void Browser::AdvancedPrint() {
   GetSelectedTabContentsWrapper()->print_view_manager()->AdvancedPrintNow();
 }
 
 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()) {
-    TabContents* contents = GetSelectedTabContents();
+    WebContents* contents = GetSelectedWebContents();
     if (contents)
       contents->ResetOverrideEncoding();
   }
 }
 
 void Browser::OverrideEncoding(int encoding_id) {
   content::RecordAction(UserMetricsAction("OverrideEncoding"));
   const std::string selected_encoding =
       CharacterEncoding::GetCanonicalEncodingNameByCommandId(encoding_id);
-  TabContents* contents = GetSelectedTabContents();
+  WebContents* contents = GetSelectedWebContents();
   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 35 matching lines @@
     return;
 
   RenderViewHost* host =
       GetSelectedTabContentsWrapper()->tab_contents()->GetRenderViewHost();
   if (zoom == content::PAGE_ZOOM_RESET) {
     host->SetZoomLevel(0);
     content::RecordAction(UserMetricsAction("ZoomNormal"));
     return;
   }
 
-  double current_zoom_level = GetSelectedTabContents()->GetZoomLevel();
+  double current_zoom_level = GetSelectedWebContents()->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 74 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(""),
-                                  GetSelectedTabContents(),
+                                  GetSelectedWebContents(),
                                   parent_window, NULL);
 }
 
 void Browser::OpenCreateShortcutsDialog() {
   content::RecordAction(UserMetricsAction("CreateShortcut"));
 #if !defined(OS_MACOSX)
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   DCHECK(current_tab &&
       web_app::IsValidUrl(current_tab->tab_contents()->GetURL())) <<
           "Menu item should be disabled.";
@@ skipping 1458 matching lines @@
 
 void Browser::DeactivateContents(WebContents* contents) {
   window_->Deactivate();
 }
 
 void Browser::LoadingStateChanged(WebContents* source) {
   window_->UpdateLoadingAnimations(
       tab_handler_->GetTabStripModel()->TabsAreLoading());
   window_->UpdateTitleBar();
 
-  WebContents* selected_contents = GetSelectedTabContents();
+  WebContents* selected_contents = GetSelectedWebContents();
   if (source == selected_contents) {
     bool is_loading = source->IsLoading();
     UpdateReloadStopState(is_loading, false);
     if (GetStatusBubble()) {
       GetStatusBubble()->SetStatus(
           GetSelectedTabContentsWrapper()->core_tab_helper()->GetStatusText());
     }
 
     if (!is_loading && pending_web_app_action_ == UPDATE_SHORTCUT) {
       // Schedule a shortcut update when web application info is available if
@@ skipping 48 matching lines @@
 bool Browser::IsPopupOrPanel(const WebContents* source) const {
   // A non-tabbed BROWSER is an unconstrained popup.
   return is_type_popup() || is_type_panel();
 }
 
 void Browser::ContentsMouseEvent(
     WebContents* source, const gfx::Point& location, bool motion) {
   if (!GetStatusBubble())
     return;
 
-  if (source == GetSelectedTabContents()) {
+  if (source == GetSelectedWebContents()) {
     GetStatusBubble()->MouseMoved(location, !motion);
     if (!motion)
       GetStatusBubble()->SetURL(GURL(), std::string());
   }
 }
 
 void Browser::UpdateTargetURL(WebContents* source, int32 page_id,
                               const GURL& url) {
   Browser::UpdateTargetURLHelper(source, page_id, url);
 
   if (!GetStatusBubble())
     return;
 
-  if (source == GetSelectedTabContents()) {
+  if (source == GetSelectedWebContents()) {
     PrefService* prefs = profile_->GetPrefs();
     GetStatusBubble()->SetURL(url, prefs->GetString(prefs::kAcceptLanguages));
   }
 }
 
 void Browser::UpdateDownloadShelfVisibility(bool visible) {
   if (GetStatusBubble())
     GetStatusBubble()->UpdateDownloadShelfVisibility(visible);
 }
 
@@ skipping 243 matching lines @@
       TabContentsWrapper::GetCurrentWrapperForContents(source);
   InfoBarTabHelper* infobar_helper = wrapper->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 == GetSelectedTabContents())
+  if (tab == GetSelectedWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 void Browser::DidNavigateToPendingEntry(WebContents* tab) {
-  if (tab == GetSelectedTabContents())
+  if (tab == GetSelectedWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 content::JavaScriptDialogCreator* Browser::GetJavaScriptDialogCreator() {
   return GetJavaScriptDialogCreatorInstance();
 }
 
 void Browser::RunFileChooser(WebContents* tab,
                              const content::FileChooserParams& params) {
   RunFileChooserHelper(tab, params);
@@ skipping 201 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 (GetSelectedTabContents() &&
-          &GetSelectedTabContents()->GetController() ==
+      if (GetSelectedWebContents() &&
+          &GetSelectedWebContents()->GetController() ==
           content::Source<NavigationController>(source).ptr())
         UpdateToolbar(false);
       break;
 
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED: {
       // Show the UI if the extension was disabled for escalated permissions.
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile_->IsSameProfile(profile)) {
         ExtensionService* service = profile->GetExtensionService();
         DCHECK(service);
@@ skipping 91 matching lines @@
         UpdateSaveAsState(GetContentRestrictionsForSelectedTab());
         UpdateOpenFileState();
       } else {
         NOTREACHED();
       }
       break;
     }
 
     case chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED: {
       WebContents* web_contents = content::Source<WebContents>(source).ptr();
-      if (web_contents == GetSelectedTabContents()) {
+      if (web_contents == GetSelectedWebContents()) {
         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 20 matching lines @@
       show_main_ui && profile_->GetOriginalProfile()->IsSyncAccessible());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, InstantDelegate implementation:
 
 void Browser::ShowInstant(TabContentsWrapper* preview_contents) {
   DCHECK(instant_->tab_contents() == GetSelectedTabContentsWrapper());
   window_->ShowInstant(preview_contents);
 
-  GetSelectedTabContents()->HideContents();
-  preview_contents->tab_contents()->ShowContents();
+  GetSelectedWebContents()->HideContents();
+  preview_contents->web_contents()->ShowContents();
 }
 
 void Browser::HideInstant() {
   window_->HideInstant();
-  if (GetSelectedTabContents())
-    GetSelectedTabContents()->ShowContents();
+  if (GetSelectedWebContents())
+    GetSelectedWebContents()->ShowContents();
   if (instant_->GetPreviewContents())
-    instant_->GetPreviewContents()->tab_contents()->HideContents();
+    instant_->GetPreviewContents()->web_contents()->HideContents();
 }
 
 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);
   // TabStripModel takes ownership of preview_contents.
   tab_handler_->GetTabStripModel()->ReplaceTabContentsAt(
       index, preview_contents);
@@ skipping 299 matching lines @@
   command_updater_.UpdateCommandEnabled(IDC_SHOW_AVATAR_MENU,
       show_main_ui && !profile()->IsOffTheRecord());
 #if defined (ENABLE_PROFILING) && !defined(NO_TCMALLOC)
   command_updater_.UpdateCommandEnabled(IDC_PROFILING_ENABLED, show_main_ui);
 #endif
 
   UpdateCommandsForBookmarkBar();
 }
 
 void Browser::UpdateCommandsForTabState() {
-  TabContents* current_tab = GetSelectedTabContents();
+  WebContents* current_tab = GetSelectedWebContents();
   TabContentsWrapper* current_tab_wrapper = GetSelectedTabContentsWrapper();
   if (!current_tab || !current_tab_wrapper)  // May be NULL during tab restore.
     return;
 
   // Navigation commands
   NavigationController& nc = current_tab->GetController();
   command_updater_.UpdateCommandEnabled(IDC_BACK, nc.CanGoBack());
   command_updater_.UpdateCommandEnabled(IDC_FORWARD, nc.CanGoForward());
   command_updater_.UpdateCommandEnabled(IDC_RELOAD,
                                         CanReloadContents(current_tab));
@@ skipping 143 matching lines @@
   window_->UpdateToolbar(GetSelectedTabContentsWrapper(), should_restore_state);
 }
 
 void Browser::ScheduleUIUpdate(const WebContents* source,
                                unsigned changed_flags) {
   if (!source)
     return;
 
   // Do some synchronous updates.
   if (changed_flags & TabContents::INVALIDATE_URL &&
-      source == GetSelectedTabContents()) {
+      source == GetSelectedWebContents()) {
     // 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 &= ~TabContents::INVALIDATE_URL;
   }
   if (changed_flags & TabContents::INVALIDATE_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 53 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 == GetSelectedTabContents()) {
+    if (contents == GetSelectedWebContents()) {
       // Updates that only matter when the tab is selected go here.
 
       if (flags & TabContents::INVALIDATE_PAGE_ACTIONS) {
         LocationBar* location_bar = window()->GetLocationBar();
         if (location_bar)
           location_bar->UpdatePageActions();
       }
       // Updating the URL happens synchronously in ScheduleUIUpdate.
       if (flags & TabContents::INVALIDATE_LOAD && GetStatusBubble()) {
         GetStatusBubble()->SetStatus(
@@ skipping 439 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;
-  TabContents* current_tab = GetSelectedTabContents();
+  WebContents* current_tab = GetSelectedWebContents();
   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 (!SavePackage::IsSavableURL(
             active_entry ? active_entry->GetURL() : GURL())
         || current_tab->ShowingInterstitialPage())
       content_restrictions |= content::CONTENT_RESTRICTION_SAVE;
     if (current_tab->ShowingInterstitialPage())
@@ skipping 55 matching lines @@
 void Browser::OnWindowDidShow() {
   if (window_has_shown_)
     return;
   window_has_shown_ = true;
 
   // Nothing to do for non-tabbed windows.
   if (!is_type_tabbed())
     return;
 
   // Suppress the first run bubble if we're showing the sync promo.
-  TabContents* contents = GetSelectedTabContents();
+  WebContents* contents = GetSelectedWebContents();
   bool is_showing_promo = contents &&
       contents->GetURL().SchemeIs(chrome::kChromeUIScheme) &&
       contents->GetURL().host() == chrome::kChromeUISyncPromoHost;
 
   // Show the First Run information bubble if we've been told to.
   PrefService* local_state = g_browser_process->local_state();
   if (!is_showing_promo && local_state &&
       local_state->GetBoolean(prefs::kShouldShowFirstRunBubble)) {
     FirstRun::BubbleType bubble_type = FirstRun::MINIMAL_BUBBLE;
     if (local_state->
@@ skipping 11 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }