Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

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 85 matching lines @@
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_content_setting_bubble_model_delegate.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_toolbar_model_delegate.h"
 #include "chrome/browser/ui/browser_ui_prefs.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
@@ skipping 381 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(GetActiveTabContents());
+    find_bar_controller_->ChangeTabContents(chrome::GetActiveTabContents(this));
     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 {
   return !app_name_.empty();
 }
 
 bool Browser::is_devtools() const {
   return app_name_ == DevToolsWindow::kDevToolsApp;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, State Storage and Retrieval for UI:
 
 SkBitmap Browser::GetCurrentPageIcon() const {
-  TabContents* contents = GetActiveTabContents();
+  TabContents* contents = chrome::GetActiveTabContents(this);
   // |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 = GetActiveWebContents();
+  WebContents* contents = chrome::GetActiveWebContents(this);
   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 75 matching lines @@
 
   if (tab_restore_service && is_type_tabbed() && tab_count())
     tab_restore_service->BrowserClosing(tab_restore_service_delegate());
 
   // TODO(sky): convert session/tab restore to use notification.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BROWSER_CLOSING,
       content::Source<Browser>(this),
       content::Details<bool>(&exiting));
 
-  CloseAllTabs();
+  chrome::CloseAllTabs(this);
 }
 
 void Browser::OnWindowActivated() {
   // On some platforms we want to automatically reload tabs that are
   // killed when the user selects them.
-  WebContents* contents = GetActiveWebContents();
+  WebContents* contents = chrome::GetActiveWebContents(this);
   if (contents && contents->GetCrashedStatus() ==
      base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kReloadKilledTabs)) {
       chrome::Reload(this, CURRENT_TAB);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 77 matching lines @@
 // Browser, TabStripModel pass-thrus:
 
 int Browser::tab_count() const {
   return tab_strip_model_->count();
 }
 
 int Browser::active_index() const {
   return tab_strip_model_->active_index();
 }
 
-int Browser::GetIndexOfController(
-    const NavigationController* controller) const {
-  return tab_strip_model_->GetIndexOfController(controller);
-}
-
-TabContents* Browser::GetActiveTabContents() const {
-  return tab_strip_model_->GetActiveTabContents();
-}
-
-WebContents* Browser::GetActiveWebContents() const {
-  TabContents* tab_contents = GetActiveTabContents();
-  return tab_contents ? tab_contents->web_contents() : NULL;
-}
-
-TabContents* Browser::GetTabContentsAt(int index) const {
-  return tab_strip_model_->GetTabContentsAt(index);
-}
-
-WebContents* Browser::GetWebContentsAt(int index) const {
-  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);
-}
-
-bool Browser::IsTabDiscarded(int index) const {
-  return tab_strip_model_->IsTabDiscarded(index);
-}
-
-void Browser::CloseAllTabs() {
-  tab_strip_model_->CloseAllTabs();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Browser, Tab adding/showing functions:
 
-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;
-}
-
-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(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();
-  TabContents* tab_contents = TabContentsFactory(
-      profile(),
-      tab_util::GetSiteInstanceForNewTab(profile_, restore_url),
-      MSG_ROUTING_NONE,
-      GetActiveWebContents(),
-      session_storage_namespace);
-  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, 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->WasHidden();
-  }
-  SessionService* session_service =
-      SessionServiceFactory::GetForProfileIfExisting(profile_);
-  if (session_service)
-    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);
-}
-
-void Browser::CloseTabContents(WebContents* contents) {
-  CloseContents(contents);
-}
-
-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();
-  TabContents* tab_contents = TabContentsFactory(
-      profile(),
-      tab_util::GetSiteInstanceForNewTab(profile_, restore_url),
-      MSG_ROUTING_NONE,
-      GetActiveWebContents(),
-      session_storage_namespace);
-  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(), tab_contents);
-}
-
 void Browser::WindowFullscreenStateChanged() {
   fullscreen_controller_->WindowFullscreenStateChanged();
   command_controller_->FullscreenStateChanged();
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TOGGLE_FULLSCREEN);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Assorted browser commands:
 
 void Browser::ToggleFullscreenMode() {
@@ skipping 19 matching lines @@
 }
 
 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 = GetActiveWebContents();
+    WebContents* contents = chrome::GetActiveWebContents(this);
     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 = GetActiveWebContents();
+  WebContents* contents = chrome::GetActiveWebContents(this);
   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);
   }
 }
 
 void Browser::OpenFile() {
   content::RecordAction(UserMetricsAction("OpenFile"));
   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_->GetNativeWindow();
   select_file_dialog_->SelectFile(SelectFileDialog::SELECT_OPEN_FILE,
                                   string16(), directory,
                                   NULL, 0, FILE_PATH_LITERAL(""),
-                                  GetActiveWebContents(),
+                                  chrome::GetActiveWebContents(this),
                                   parent_window, NULL);
 }
 
 void Browser::OpenCreateShortcutsDialog() {
   content::RecordAction(UserMetricsAction("CreateShortcut"));
 #if !defined(OS_MACOSX)
-  TabContents* current_tab = GetActiveTabContents();
+  TabContents* current_tab = chrome::GetActiveTabContents(this);
   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.
@@ skipping 146 matching lines @@
                                                    selection_rect,
                                                    active_match_ordinal,
                                                    final_update);
 }
 
 void Browser::UpdateUIForNavigationInTab(TabContents* contents,
                                          content::PageTransition transition,
                                          bool user_initiated) {
   tab_strip_model_->TabNavigating(contents, transition);
 
-  bool contents_is_selected = contents == GetActiveTabContents();
+  bool contents_is_selected = contents == chrome::GetActiveTabContents(this);
   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();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, PageNavigator implementation:
 
 WebContents* Browser::OpenURL(const OpenURLParams& params) {
   return OpenURLFromTab(NULL, params);
 }
 
-// Centralized method for creating a TabContents, configuring and
-// installing all its supporting objects and observers.
-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);
-  TabContents* tab_contents = new TabContents(new_contents);
-  return tab_contents;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelDelegate implementation:
 
 TabContents* Browser::AddBlankTab(bool foreground) {
   return AddBlankTabAt(-1, 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
@@ skipping 35 matching lines @@
 
 int Browser::GetDragActions() const {
   return TabStripModelDelegate::TAB_TEAROFF_ACTION | (tab_count() > 1 ?
       TabStripModelDelegate::TAB_MOVE_ACTION : 0);
 }
 
 TabContents* Browser::CreateTabContentsForURL(
     const GURL& url, const content::Referrer& referrer, Profile* profile,
     content::PageTransition transition, bool defer_load,
     SiteInstance* instance) const {
-  TabContents* contents = TabContentsFactory(profile, instance,
-      MSG_ROUTING_NONE, GetActiveWebContents(), NULL);
+  TabContents* contents = chrome::TabContentsFactory(profile, instance,
+      MSG_ROUTING_NONE, chrome::GetActiveWebContents(this), 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();
+  NavigationController& nc =
+      chrome::GetWebContentsAt(this, index)->GetController();
   return nc.GetWebContents() && nc.GetLastCommittedEntry();
 }
 
 void Browser::DuplicateContentsAt(int index) {
-  TabContents* contents = GetTabContentsAt(index);
+  TabContents* contents = chrome::GetTabContentsAt(this, index);
   CHECK(contents);
   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);
+    pinned = tab_strip_model_->IsTabPinned(index);
     int add_types = TabStripModel::ADD_ACTIVE |
         TabStripModel::ADD_INHERIT_GROUP |
         (pinned ? TabStripModel::ADD_PINNED : 0);
     tab_strip_model_->InsertTabContentsAt(index + 1, contents_dupe, add_types);
   } else {
     Browser* browser = NULL;
     if (is_app()) {
       CHECK(!is_type_popup());
       CHECK(!is_type_panel());
       browser = Browser::CreateWithParams(
           Browser::CreateParams::CreateForApp(
               TYPE_POPUP, app_name_, gfx::Rect(),profile_));
     } else if (is_type_popup()) {
       browser = Browser::CreateWithParams(
           Browser::CreateParams(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
     // WebContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
-    browser->AddTab(contents_dupe, content::PAGE_TRANSITION_LINK);
+    chrome::AddTab(browser, contents_dupe, content::PAGE_TRANSITION_LINK);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(contents_dupe, pinned);
 }
 
 void Browser::CloseFrameAfterDragSession() {
 #if !defined(OS_MACOSX)
@@ skipping 117 matching lines @@
       LOG(WARNING) << "Reloading killed tab at " << index;
       static int reload_count = 0;
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Tabs.SadTab.ReloadCount", ++reload_count, 1, 1000, 50);
       chrome::Reload(this, CURRENT_TAB);
       did_reload = true;
     }
   }
 
   // Discarded tabs always get reloaded.
-  if (!did_reload && IsTabDiscarded(index)) {
+  if (!did_reload && tab_strip_model_->IsTabDiscarded(index)) {
     LOG(WARNING) << "Reloading discarded tab at " << index;
     static int reload_count = 0;
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Tabs.Discard.ReloadCount", ++reload_count, 1, 1000, 50);
     chrome::Reload(this, CURRENT_TAB);
   }
 
   // If we have any update pending, do it now.
   if (chrome_updater_factory_.HasWeakPtrs() && old_contents)
     ProcessPendingUIUpdates();
@@ skipping 11 matching lines @@
   // Update commands to reflect current state.
   command_controller_->TabStateChanged();
 
   // Reset the status bubble.
   StatusBubble* status_bubble = GetStatusBubble();
   if (status_bubble) {
     status_bubble->Hide();
 
     // Show the loading state (if any).
     status_bubble->SetStatus(
-        GetActiveTabContents()->core_tab_helper()->GetStatusText());
+        chrome::GetActiveTabContents(this)->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 =
@@ skipping 28 matching lines @@
         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));
+    session_service->TabRestored(new_contents,
+                                 tab_strip_model_->IsTabPinned(index));
   }
 
   content::DevToolsManager::GetInstance()->ContentsReplaced(
       old_contents->web_contents(), new_contents->web_contents());
 }
 
 void Browser::TabPinnedStateChanged(TabContents* contents, int index) {
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     session_service->SetPinnedState(
         session_id(),
-        GetTabContentsAt(index)->restore_tab_helper()->session_id(),
-        IsTabPinned(index));
+        chrome::GetTabContentsAt(this, index)->restore_tab_helper()->
+            session_id(),
+        tab_strip_model_->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
   //       still present.
@@ skipping 25 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 = GetTabContentsAt(i)->web_contents();
+      WebContents* contents = chrome::GetTabContentsAt(this, 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 = GetTabContentsAt(
+  nav_params.source_contents = chrome::GetTabContentsAt(this,
       tab_strip_model_->GetIndexOfWebContents(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 16 matching lines @@
   if (changed_flags & (content::INVALIDATE_TYPE_URL |
                        content::INVALIDATE_TYPE_LOAD))
     command_controller_->TabStateChanged();
 }
 
 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);
-
-  TabContents* source_tab_contents = NULL;
-  BlockedContentTabHelper* source_blocked_content = NULL;
-  TabContents* new_tab_contents = TabContents::FromWebContents(new_contents);
-  if (!new_tab_contents) {
-    new_tab_contents = new TabContents(new_contents);
-  }
-  if (source) {
-    source_tab_contents = TabContents::FromWebContents(source);
-    source_blocked_content = source_tab_contents->blocked_content_tab_helper();
-  }
-
-  if (source_tab_contents) {
-    // Handle blocking of all contents.
-    if (source_blocked_content->all_contents_blocked()) {
-      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.
-      GetConstrainingTabContents(source_tab_contents)->
-          blocked_content_tab_helper()->
-              AddPopup(new_tab_contents, initial_pos, user_gesture);
-      return;
-    }
-
-    new_contents->GetRenderViewHost()->DisassociateFromPopupCount();
-  }
-
-  browser::NavigateParams params(this, new_tab_contents);
-  params.source_contents = source ?
-      GetTabContentsAt(tab_strip_model_->GetIndexOfWebContents(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);
+  chrome::AddWebContents(this, source, new_contents, disposition, initial_pos,
+                         user_gesture);
 }
 
 void Browser::ActivateContents(WebContents* contents) {
-  ActivateTabAt(tab_strip_model_->GetIndexOfWebContents(contents), false);
+  chrome::ActivateTabAt(this, tab_strip_model_->GetIndexOfWebContents(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 = GetActiveWebContents();
+  WebContents* selected_contents = chrome::GetActiveWebContents(this);
   if (source == selected_contents) {
     bool is_loading = source->IsLoading();
     command_controller_->LoadingStateChanged(is_loading, false);
     if (GetStatusBubble()) {
       GetStatusBubble()->SetStatus(
-          GetActiveTabContents()->core_tab_helper()->GetStatusText());
+          chrome::GetActiveTabContents(this)->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) {
         TabContents::FromWebContents(source)->
             extension_tab_helper()->GetApplicationInfo(entry->GetPageID());
       } else {
         pending_web_app_action_ = NONE;
       }
     }
   }
 }
 
 void Browser::CloseContents(WebContents* 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, true);
     return;
   }
 
-  int index = tab_strip_model_->GetIndexOfWebContents(source);
-  if (index == TabStripModel::kNoTab) {
-    NOTREACHED() << "CloseContents called for tab not in our strip";
-    return;
-  }
-  tab_strip_model_->CloseTabContentsAt(index,
-      TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
+  chrome::CloseWebContents(this, source);
 }
 
 void Browser::MoveContents(WebContents* source, const gfx::Rect& pos) {
   if (!IsPopupOrPanel(source)) {
     NOTREACHED() << "moving invalid browser type";
     return;
   }
   window_->SetBounds(pos);
 }
 
 bool Browser::IsPopupOrPanel(const WebContents* source) const {
   // A non-tabbed BROWSER is an unconstrained popup.
   return is_type_popup() || is_type_panel();
 }
 
 void Browser::UpdateTargetURL(WebContents* source, int32 page_id,
                               const GURL& url) {
   if (!GetStatusBubble())
     return;
 
-  if (source == GetActiveWebContents()) {
+  if (source == chrome::GetActiveWebContents(this)) {
     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 == GetActiveWebContents()) {
+  if (source == chrome::GetActiveWebContents(this)) {
     GetStatusBubble()->MouseMoved(location, !motion);
     if (!motion)
       GetStatusBubble()->SetURL(GURL(), std::string());
   }
 }
 
 void Browser::ContentsZoomChange(bool zoom_in) {
   chrome::ExecuteCommand(this, zoom_in ? IDC_ZOOM_PLUS : IDC_ZOOM_MINUS);
 }
 
@@ skipping 85 matching lines @@
   // 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()->GetActiveWebContents();
+  WebContents* shelf_tab = chrome::GetActiveWebContents(shelf->browser());
   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);
-  TabContents* tab_contents = GetTabContentsAt(
+  TabContents* tab_contents = chrome::GetTabContentsAt(this,
       tab_strip_model_->GetIndexOfWebContents(source));
   chrome::ViewSource(this, tab_contents);
 }
 
 void Browser::ViewSourceForFrame(WebContents* source,
                                  const GURL& frame_url,
                                  const std::string& frame_content_state) {
   DCHECK(source);
-  TabContents* tab_contents = GetTabContentsAt(
+  TabContents* tab_contents = chrome::GetTabContentsAt(this,
       tab_strip_model_->GetIndexOfWebContents(source));
   chrome::ViewSource(this, tab_contents, frame_url, frame_content_state);
 }
 
 void Browser::ShowRepostFormWarningDialog(WebContents* source) {
   browser::ShowTabModalConfirmDialog(
       new RepostFormWarningController(source),
       TabContents::FromWebContents(source));
 }
 
@@ skipping 73 matching lines @@
   TabContents* tab_contents = TabContents::FromWebContents(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* web_contents) {
-  if (web_contents == GetActiveWebContents())
+  if (web_contents == chrome::GetActiveWebContents(this))
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 void Browser::DidNavigateToPendingEntry(WebContents* web_contents) {
-  if (web_contents == GetActiveWebContents())
+  if (web_contents == chrome::GetActiveWebContents(this))
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 content::JavaScriptDialogCreator* Browser::GetJavaScriptDialogCreator() {
   return GetJavaScriptDialogCreatorInstance();
 }
 
 content::ColorChooser* Browser::OpenColorChooser(WebContents* web_contents,
                                                  int color_chooser_id,
                                                  SkColor color) {
@@ skipping 64 matching lines @@
     WebContents* web_contents,
     content::WebIntentsDispatcher* intents_dispatcher) {
   if (!web_intents::IsWebIntentsEnabledForProfile(profile_))
     return;
 
   UMA_HISTOGRAM_COUNTS("WebIntents.Dispatch", 1);
 
   if (!web_contents) {
     // Intent is system-caused and the picker will show over the currently
     // active web contents.
-    web_contents = GetActiveWebContents();
+    web_contents = chrome::GetActiveWebContents(this);
   }
   TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   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,
@@ skipping 88 matching lines @@
 // Browser, ConstrainedWindowTabHelperDelegate implementation:
 
 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);
   command_controller_->PrintingStateChanged();
-  if (!blocked && GetActiveTabContents() == tab_contents)
+  if (!blocked && chrome::GetActiveTabContents(this) == tab_contents)
     tab_contents->web_contents()->Focus();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, BlockedContentTabHelperDelegate implementation:
 
 TabContents* Browser::GetConstrainingTabContents(TabContents* source) {
   return source;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, BookmarkTabHelperDelegate implementation:
 
 void Browser::URLStarredChanged(TabContents* source, bool starred) {
-  if (source == GetActiveTabContents())
+  if (source == chrome::GetActiveTabContents(this))
     window_->SetStarredState(starred);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, ZoomObserver implementation:
 
 void Browser::OnZoomIconChanged(TabContents* source,
                                 ZoomController::ZoomIconState state) {
-  if (source == GetActiveTabContents())
+  if (source == chrome::GetActiveTabContents(this))
     window_->SetZoomIconState(state);
 }
 
 void Browser::OnZoomChanged(TabContents* source,
                             int zoom_percent,
                             bool can_show_bubble) {
-  if (source == GetActiveTabContents()) {
+  if (source == chrome::GetActiveTabContents(this)) {
     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(TabContents* source,
                                       int32 page_id) {
-  if (GetActiveTabContents() != source)
+  if (chrome::GetActiveTabContents(this) != 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);
@@ skipping 59 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 (GetActiveWebContents() &&
-          &GetActiveWebContents()->GetController() ==
+      if (chrome::GetActiveWebContents(this) &&
+          &chrome::GetActiveWebContents(this)->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.
       if (content::Details<extensions::UnloadedExtensionInfo>(
             details)->reason != extension_misc::UNLOAD_REASON_TERMINATE) {
         const Extension* extension =
             content::Details<extensions::UnloadedExtensionInfo>(
                 details)->extension;
         for (int i = tab_strip_model_->count() - 1; i >= 0; --i) {
-          WebContents* tc =
-              tab_strip_model_->GetTabContentsAt(i)->web_contents();
+          WebContents* tc = chrome::GetTabContentsAt(this, i)->web_contents();
           bool close_tab_contents =
               tc->GetURL().SchemeIs(chrome::kExtensionScheme) &&
               tc->GetURL().host() == extension->id();
           // We want to close all panels originated by the unloaded extension.
           close_tab_contents = close_tab_contents ||
               (type_ == TYPE_PANEL &&
                (web_app::GetExtensionIdFromApplicationName(app_name_) ==
                 extension->id()));
-          if (close_tab_contents) {
-            CloseTabContents(tc);
-          }
+          if (close_tab_contents)
+            chrome::CloseWebContents(this, tc);
         }
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile_->IsSameProfile(profile) && window()->GetLocationBar())
         window()->GetLocationBar()->InvalidatePageActions();
       break;
@@ skipping 38 matching lines @@
         PrefService* pref_service = content::Source<PrefService>(source).ptr();
         MarkHomePageAsChanged(pref_service);
       } else {
         NOTREACHED();
       }
       break;
     }
 
     case chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED: {
       WebContents* web_contents = content::Source<WebContents>(source).ptr();
-      if (web_contents == GetActiveWebContents()) {
+      if (web_contents == chrome::GetActiveWebContents(this)) {
         LocationBar* location_bar = window()->GetLocationBar();
         if (location_bar)
           location_bar->UpdateContentSettingsIcons();
       }
       break;
     }
 
     case content::NOTIFICATION_INTERSTITIAL_ATTACHED:
       UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
       break;
 
     case content::NOTIFICATION_INTERSTITIAL_DETACHED:
       UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
       break;
 
     default:
       NOTREACHED() << "Got a notification we didn't register for.";
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, InstantControllerDelegate implementation:
 
 void Browser::ShowInstant(TabContents* preview_contents) {
   window_->ShowInstant(preview_contents);
 
   // TODO(beng): investigate if we can avoid this and instead rely on the
   //             visibility of the WebContentsView
-  GetActiveWebContents()->WasHidden();
+  chrome::GetActiveWebContents(this)->WasHidden();
   preview_contents->web_contents()->WasRestored();
 }
 
 void Browser::HideInstant() {
   window_->HideInstant();
-  if (GetActiveWebContents())
-    GetActiveWebContents()->WasRestored();
+  if (chrome::GetActiveWebContents(this))
+    chrome::GetActiveWebContents(this)->WasRestored();
   if (instant_->GetPreviewContents())
     instant_->GetPreviewContents()->web_contents()->WasHidden();
 }
 
 void Browser::CommitInstant(TabContents* preview_contents) {
-  TabContents* tab_contents = GetActiveTabContents();
+  TabContents* tab_contents = chrome::GetActiveTabContents(this);
   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 11 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());
 }
 
 TabContents* Browser::GetInstantHostTabContents() const {
-  return GetActiveTabContents();
+  return chrome::GetActiveTabContents(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Command and state updating (private):
 
 void Browser::MarkHomePageAsChanged(PrefService* pref_service) {
   pref_service->SetBoolean(prefs::kHomePageChanged, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, UI update coalescing and handling (private):
 
 void Browser::UpdateToolbar(bool should_restore_state) {
-  window_->UpdateToolbar(GetActiveTabContents(), should_restore_state);
+  window_->UpdateToolbar(chrome::GetActiveTabContents(this),
+                         should_restore_state);
 }
 
 void Browser::UpdateSearchState(TabContents* contents) {
   if (chrome::search::IsInstantExtendedAPIEnabled(profile_))
     search_delegate_->OnTabActivated(contents);
 }
 
 void Browser::ScheduleUIUpdate(const WebContents* source,
                                unsigned changed_flags) {
   if (!source)
     return;
 
   // Do some synchronous updates.
   if (changed_flags & content::INVALIDATE_TYPE_URL &&
-      source == GetActiveWebContents()) {
+      source == chrome::GetActiveWebContents(this)) {
     // 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.
     tab_strip_model_->UpdateTabContentsStateAt(
-        GetIndexOfController(&source->GetController()),
+        chrome::GetIndexOfTab(this, source),
         TabStripModelObserver::LOADING_ONLY);
     // The status bubble needs to be updated during INVALIDATE_TYPE_LOAD too,
     // but we do that asynchronously by not stripping INVALIDATE_TYPE_LOAD from
     // changed_flags.
   }
 
   if (changed_flags & content::INVALIDATE_TYPE_TITLE && !source->IsLoading()) {
     // To correctly calculate whether the title changed while not loading
     // we need to process the update synchronously. This state only matters for
     // the TabStripModel, so we notify the TabStripModel now and notify others
     // asynchronously.
     tab_strip_model_->UpdateTabContentsStateAt(
-        GetIndexOfController(&source->GetController()),
+        chrome::GetIndexOfTab(this, source),
         TabStripModelObserver::TITLE_NOT_LOADING);
   }
 
   // If the only updates were synchronously handled above, we're done.
   if (changed_flags == 0)
     return;
 
   // Save the dirty bits.
   scheduled_updates_[source] |= changed_flags;
 
   if (!chrome_updater_factory_.HasWeakPtrs()) {
     // No task currently scheduled, start another.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&Browser::ProcessPendingUIUpdates,
                    chrome_updater_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kUIUpdateCoalescingTimeMS));
   }
 }
 
 void Browser::ProcessPendingUIUpdates() {
 #ifndef NDEBUG
   // Validate that all tabs we have pending updates for exist. This is scary
   // because the pending list must be kept in sync with any detached or
   // deleted tabs.
   for (UpdateMap::const_iterator i = scheduled_updates_.begin();
        i != scheduled_updates_.end(); ++i) {
     bool found = false;
     for (int tab = 0; tab < tab_count(); tab++) {
-      if (GetWebContentsAt(tab) == i->first) {
+      if (chrome::GetWebContentsAt(this, tab) == i->first) {
         found = true;
         break;
       }
     }
     DCHECK(found);
   }
 #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 == GetActiveWebContents()) {
+    if (contents == chrome::GetActiveWebContents(this)) {
       // 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(
-            GetActiveTabContents()->
-                core_tab_helper()->GetStatusText());
+        GetStatusBubble()->SetStatus(chrome::GetActiveTabContents(this)->
+            core_tab_helper()->GetStatusText());
       }
 
       if (flags & (content::INVALIDATE_TYPE_TAB |
                    content::INVALIDATE_TYPE_TITLE)) {
         window_->UpdateTitleBar();
       }
     }
 
     // Updates that don't depend upon the selected state go here.
     if (flags &
@@ skipping 30 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) {
-      TabContents* tab = GetTabContentsAt(i);
+      TabContents* tab = chrome::GetTabContentsAt(this, 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));
+            tab_strip_model_->IsTabPinned(i));
       }
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, OnBeforeUnload handling (private):
 
 void Browser::ProcessPendingTabs() {
   if (!is_attempting_to_close_browser_) {
@@ skipping 133 matching lines @@
   window_->Close();
 }
 
 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 == GetActiveTabContents()) {
+    if (contents == chrome::GetActiveTabContents(this)) {
       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 62 matching lines @@
 }
 
 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 {
-    TabContents* tab = GetActiveTabContents();
+    TabContents* tab = chrome::GetActiveTabContents(this);
     if (tab && tab->bookmark_tab_helper()->ShouldShowBookmarkBar())
       state = BookmarkBar::DETACHED;
     else
       state = BookmarkBar::HIDDEN;
   }
 
   // Only allow the bookmark bar to be shown in default mode.
   if (!search_model_->mode().is_default())
     state = BookmarkBar::HIDDEN;
 
@@ skipping 92 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;
 }