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

chrome/browser/bookmarks/bookmark_utils.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/bookmarks/bookmark_utils.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 139 matching lines @@
       disposition = initial_disposition;
     (*navigator)->OpenURL(OpenURLParams(node->url(), content::Referrer(),
                           disposition, content::PAGE_TRANSITION_AUTO_BOOKMARK,
                           false));
     if (!*opened_url) {
       *opened_url = true;
       // We opened the first URL which may have opened a new window or clobbered
       // the current page, reset the navigator just to be sure.
       Browser* new_browser = BrowserList::GetLastActiveWithProfile(profile);
       if (new_browser) {
-        TabContents* current_tab = new_browser->GetSelectedTabContents();
+        WebContents* current_tab = new_browser->GetSelectedWebContents();
         DCHECK(new_browser && current_tab);
         if (new_browser && current_tab)
           *navigator = current_tab;
       }  // else, new_browser == NULL, which happens during testing.
     }
   } else {
     // For folders only open direct children.
     for (int i = 0; i < node->child_count(); ++i) {
       const BookmarkNode* child_node = node->GetChild(i);
       if (child_node->is_url())
@@ skipping 207 matching lines @@
              Profile* profile,
              PageNavigator* navigator,
              const std::vector<const BookmarkNode*>& nodes,
              WindowOpenDisposition initial_disposition) {
   if (!ShouldOpenAll(parent, nodes))
     return;
 
   NewBrowserPageNavigator navigator_impl(profile);
   if (!navigator) {
     Browser* browser = BrowserList::FindTabbedBrowser(profile, false);
-    if (!browser || !browser->GetSelectedTabContents()) {
+    if (!browser || !browser->GetSelectedWebContents()) {
       navigator = &navigator_impl;
     } else {
       if (initial_disposition != NEW_WINDOW &&
           initial_disposition != OFF_THE_RECORD) {
         browser->window()->Activate();
       }
-      navigator = browser->GetSelectedTabContents();
+      navigator = browser->GetSelectedWebContents();
     }
   }
 
   bool opened_url = false;
   if (initial_disposition == OFF_THE_RECORD)
     profile = profile->GetOffTheRecordProfile();
 
   for (size_t i = 0; i < nodes.size(); ++i)
     OpenAllImpl(nodes[i], initial_disposition, &navigator, profile,
                 &opened_url);
@@ skipping 239 matching lines @@
 
 void RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kShowBookmarkBar,
                              false,
                              PrefService::SYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kEditBookmarksEnabled,
                              true,
                              PrefService::UNSYNCABLE_PREF);
 }
 
-void GetURLAndTitleToBookmark(TabContents* tab_contents,
+void GetURLAndTitleToBookmark(WebContents* web_contents,
                               GURL* url,
                               string16* title) {
-  *url = tab_contents->GetURL();
-  *title = tab_contents->GetTitle();
+  *url = web_contents->GetURL();
+  *title = web_contents->GetTitle();
 }
 
 void GetURLAndTitleToBookmarkFromCurrentTab(Profile* profile,
                                             GURL* url,
                                             string16* title) {
   Browser* browser = BrowserList::GetLastActiveWithProfile(profile);
-  TabContents* tab_contents = browser ? browser->GetSelectedTabContents()
+  WebContents* web_contents = browser ? browser->GetSelectedWebContents()
                                         : NULL;
-  if (tab_contents)
-    GetURLAndTitleToBookmark(tab_contents, url, title);
+  if (web_contents)
+    GetURLAndTitleToBookmark(web_contents, url, title);
 }
 
 void GetURLsForOpenTabs(
     Browser* browser,
     std::vector<std::pair<GURL, string16> >* urls) {
   for (int i = 0; i < browser->tab_count(); ++i) {
     std::pair<GURL, string16> entry;
     GetURLAndTitleToBookmark(browser->GetTabContentsAt(i), &(entry.first),
                              &(entry.second));
     urls->push_back(entry);
@@ skipping 90 matching lines @@
 void RecordBookmarkLaunch(BookmarkLaunchLocation location) {
 #if defined(OS_WIN)
   // TODO(estade): do this on other platforms too. For now it's compiled out
   // so that stats from platforms for which this is incompletely implemented
   // don't mix in with Windows, where it should be implemented exhaustively.
   UMA_HISTOGRAM_ENUMERATION("Bookmarks.LaunchLocation", location, LAUNCH_LIMIT);
 #endif
 }
 
 }  // namespace bookmark_utils