Cleanup: Use TabStripModel pass-thrus in more places, use to be removed tabstrip_model() accessor i…

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 1174 matching lines @@
 int Browser::active_index() const {
   return tab_handler_->GetTabStripModel()->active_index();
 }
 
 int Browser::GetIndexOfController(
     const NavigationController* controller) const {
   return tab_handler_->GetTabStripModel()->GetIndexOfController(controller);
 }
 
 TabContentsWrapper* Browser::GetSelectedTabContentsWrapper() const {
-  return tabstrip_model()->GetActiveTabContents();
+  return tab_handler_->GetTabStripModel()->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);
+  return tab_handler_->GetTabStripModel()->GetTabContentsAt(index);
 }
 
 WebContents* Browser::GetWebContentsAt(int index) const {
-  TabContentsWrapper* wrapper = tabstrip_model()->GetTabContentsAt(index);
+  TabContentsWrapper* wrapper = GetTabContentsWrapperAt(index);
   if (wrapper)
     return wrapper->web_contents();
   return NULL;
 }
 
 void Browser::ActivateTabAt(int index, bool user_gesture) {
   tab_handler_->GetTabStripModel()->ActivateTabAt(index, user_gesture);
 }
 
 bool Browser::IsTabPinned(int index) const {
-  return tabstrip_model()->IsTabPinned(index);
+  return tab_handler_->GetTabStripModel()->IsTabPinned(index);
 }
 
 bool Browser::IsTabDiscarded(int index) const {
   return tab_handler_->GetTabStripModel()->IsTabDiscarded(index);
 }
 
 void Browser::CloseAllTabs() {
   tab_handler_->GetTabStripModel()->CloseAllTabs();
 }
 
@@ skipping 90 matching lines @@
   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) {
-    tab_index = std::min(tab_index, tabstrip_model()->IndexOfFirstNonMiniTab());
+    int first_mini_tab_idx =
+        tab_handler_->GetTabStripModel()->IndexOfFirstNonMiniTab();
+    tab_index = std::min(tab_index, first_mini_tab_idx);
     add_types |= TabStripModel::ADD_PINNED;
   }
   tab_handler_->GetTabStripModel()->InsertTabContentsAt(tab_index, wrapper,
                                                         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
@@ skipping 27 matching lines @@
   wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
   WebContents* replacement = wrapper->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_handler_->GetTabStripModel()->ReplaceNavigationControllerAt(
-      tab_handler_->GetTabStripModel()->active_index(),
-      wrapper);
+      active_index(), wrapper);
 }
 
 bool Browser::CanRestoreTab() {
   return command_updater_.IsCommandEnabled(IDC_RESTORE_TAB);
 }
 
 bool Browser::NavigateToIndexWithDisposition(int index,
                                              WindowOpenDisposition disp) {
   NavigationController& controller =
       GetOrCloneTabForDisposition(disp)->GetController();
@@ skipping 237 matching lines @@
   DCHECK(profile_->GetExtensionService());
   if (profile_->GetExtensionService()->IsInstalledApp(url)) {
     UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppLaunchHistogram,
                               extension_misc::APP_LAUNCH_OMNIBOX_LOCATION,
                               extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
   }
 }
 
 void Browser::Stop() {
   content::RecordAction(UserMetricsAction("Stop"));
-  GetSelectedTabContentsWrapper()->web_contents()->Stop();
+  GetSelectedWebContents()->Stop();
 }
 
 void Browser::NewWindow() {
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
       IncognitoModePrefs::ShouldLaunchIncognito(
           *CommandLine::ForCurrentProcess(), profile_->GetPrefs())) {
     NewIncognitoWindow();
     return;
   }
   content::RecordAction(UserMetricsAction("NewWindow"));
@@ skipping 19 matching lines @@
 void Browser::CloseWindow() {
   content::RecordAction(UserMetricsAction("CloseWindow"));
   window_->Close();
 }
 
 void Browser::NewTab() {
   content::RecordAction(UserMetricsAction("NewTab"));
 
   if (is_type_tabbed()) {
     AddBlankTab(true);
-    GetSelectedTabContentsWrapper()->web_contents()->GetView()->RestoreFocus();
+    GetSelectedWebContents()->GetView()->RestoreFocus();
   } 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->GetSelectedTabContentsWrapper()->web_contents()->GetView()->
-        RestoreFocus();
+    b->GetSelectedWebContents()->GetView()->RestoreFocus();
   }
 }
 
 void Browser::CloseTab() {
   content::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   if (CanCloseTab())
     tab_handler_->GetTabStripModel()->CloseSelectedTabs();
 }
 
 void Browser::SelectNextTab() {
@@ skipping 26 matching lines @@
 }
 
 void Browser::MoveTabPrevious() {
   content::RecordAction(UserMetricsAction("MoveTabPrevious"));
   tab_handler_->GetTabStripModel()->MoveTabPrevious();
 }
 
 void Browser::SelectNumberedTab(int index) {
   if (index < tab_count()) {
     content::RecordAction(UserMetricsAction("SelectNumberedTab"));
-    tab_handler_->GetTabStripModel()->ActivateTabAt(index, true);
+    ActivateTabAt(index, true);
   }
 }
 
 void Browser::SelectLastTab() {
   content::RecordAction(UserMetricsAction("SelectLastTab"));
   tab_handler_->GetTabStripModel()->SelectLastTab();
 }
 
 void Browser::DuplicateTab() {
   content::RecordAction(UserMetricsAction("Duplicate"));
@@ skipping 20 matching lines @@
     return;
 
   chrome_browser_net::WriteURLToClipboard(
       contents->GetURL(),
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void Browser::ConvertPopupToTabbedBrowser() {
   content::RecordAction(UserMetricsAction("ShowAsTab"));
-  int tab_strip_index = tab_handler_->GetTabStripModel()->active_index();
   TabContentsWrapper* contents =
-      tab_handler_->GetTabStripModel()->DetachTabContentsAt(tab_strip_index);
+      tab_handler_->GetTabStripModel()->DetachTabContentsAt(active_index());
   Browser* browser = Browser::Create(profile_);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 // TODO(koz): Change |for_tab| to an enum.
 void Browser::ToggleFullscreenMode(bool for_tab) {
   fullscreen_controller_->ToggleFullscreenMode(for_tab);
 }
 
@@ skipping 173 matching lines @@
 
 void Browser::FindPrevious() {
   content::RecordAction(UserMetricsAction("FindPrevious"));
   FindInPage(true, false);
 }
 
 void Browser::Zoom(content::PageZoom zoom) {
   if (is_devtools())
     return;
 
-  RenderViewHost* host =
-      GetSelectedTabContentsWrapper()->web_contents()->GetRenderViewHost();
+  RenderViewHost* host = GetSelectedWebContents()->GetRenderViewHost();
   if (zoom == content::PAGE_ZOOM_RESET) {
     host->SetZoomLevel(0);
     content::RecordAction(UserMetricsAction("ZoomNormal"));
     return;
   }
 
   double current_zoom_level = GetSelectedWebContents()->GetZoomLevel();
   double default_zoom_level =
       profile_->GetPrefs()->GetDouble(prefs::kDefaultZoomLevel);
 
@@ skipping 117 matching lines @@
 #endif
 }
 
 void Browser::ToggleDevToolsWindow(DevToolsToggleAction action) {
   if (action == DEVTOOLS_TOGGLE_ACTION_SHOW_CONSOLE)
     content::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
   else
     content::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
 
   DevToolsWindow::ToggleDevToolsWindow(
-      GetSelectedTabContentsWrapper()->web_contents()->GetRenderViewHost(),
+      GetSelectedWebContents()->GetRenderViewHost(),
       action);
 }
 
 void Browser::OpenTaskManager(bool highlight_background_resources) {
   content::RecordAction(UserMetricsAction("TaskManager"));
   if (highlight_background_resources)
     window_->ShowBackgroundPages();
   else
     window_->ShowTaskManager();
 }
@@ skipping 485 matching lines @@
     return true;
   }
   return false;
 }
 
 // static
 Browser* Browser::GetBrowserForController(
     const NavigationController* controller, int* index_result) {
   BrowserList::const_iterator it;
   for (it = BrowserList::begin(); it != BrowserList::end(); ++it) {
-    int index = (*it)->tab_handler_->GetTabStripModel()->GetIndexOfController(
-        controller);
+    int index = (*it)->GetIndexOfController(controller);
     if (index != TabStripModel::kNoTab) {
       if (index_result)
         *index_result = index;
       return *it;
     }
   }
 
   return NULL;
 }
 
@@ skipping 453 matching lines @@
 
 int Browser::GetLastBlockedCommand(WindowOpenDisposition* disposition) {
   if (disposition)
     *disposition = last_blocked_command_disposition_;
   return last_blocked_command_id_;
 }
 
 void Browser::UpdateUIForNavigationInTab(TabContentsWrapper* contents,
                                          content::PageTransition transition,
                                          bool user_initiated) {
-  tabstrip_model()->TabNavigating(contents, transition);
+  tab_handler_->GetTabStripModel()->TabNavigating(contents, transition);
 
   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())
@@ skipping 113 matching lines @@
   TabContentsWrapper* contents = GetTabContentsWrapperAt(index);
   CHECK(contents);
   TabContentsWrapper* 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_handler_->GetTabStripModel()->
         GetIndexOfTabContents(contents);
-    pinned = tab_handler_->GetTabStripModel()->IsTabPinned(index);
+    pinned = IsTabPinned(index);
     int add_types = TabStripModel::ADD_ACTIVE |
         TabStripModel::ADD_INHERIT_GROUP |
         (pinned ? TabStripModel::ADD_PINNED : 0);
     tab_handler_->GetTabStripModel()->InsertTabContentsAt(index + 1,
                                                           contents_dupe,
                                                           add_types);
   } else {
     Browser* browser = NULL;
     if (is_app()) {
       CHECK(!is_type_popup());
@@ skipping 68 matching lines @@
   TabCloseableStateWatcher* watcher =
       g_browser_process->tab_closeable_state_watcher();
   bool can_close_all = !watcher || watcher->CanCloseTabs(this, indices);
   if (indices->empty())  // Cannot close any tab.
     return false;
   // Now, handle cases where at least one tab can be closed.
   // If we are closing all the tabs for this browser, make sure to check for
   // in-progress downloads.
   // Note that the next call when it returns false will ask the user for
   // confirmation before closing the browser if the user decides so.
-  if (tab_handler_->GetTabStripModel()->count() ==
-          static_cast<int>(indices->size()) &&
+  if (tab_count() == static_cast<int>(indices->size()) &&
       !CanCloseWithInProgressDownloads()) {
     indices->clear();
     can_close_all = false;
   }
   return can_close_all;
 }
 
 bool Browser::CanBookmarkAllTabs() const {
   BookmarkModel* model = profile()->GetBookmarkModel();
   return (model && model->IsLoaded()) &&
@@ skipping 120 matching lines @@
   if (HasFindBarController()) {
     find_bar_controller_->ChangeTabContents(new_contents);
     find_bar_controller_->find_bar()->MoveWindowIfNecessary(gfx::Rect(), true);
   }
 
   // Update sessions. Don't force creation of sessions. If sessions doesn't
   // exist, the change will be picked up by sessions when created.
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service && !tab_handler_->GetTabStripModel()->closing_all()) {
-    session_service->SetSelectedTabInWindow(
-        session_id(), tab_handler_->GetTabStripModel()->active_index());
+    session_service->SetSelectedTabInWindow(session_id(), active_index());
   }
 
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_SWITCH);
 }
 
 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(TabStripModel* tab_strip_model,
                             TabContentsWrapper* old_contents,
                             TabContentsWrapper* new_contents,
                             int index) {
   TabDetachedAtImpl(old_contents, index, DETACH_TYPE_REPLACE);
-  TabInsertedAt(new_contents, index,
-                (index == tab_handler_->GetTabStripModel()->active_index()));
+  TabInsertedAt(new_contents, index, (index == active_index()));
 
   int entry_count =
       new_contents->web_contents()->GetController().GetEntryCount();
   if (entry_count > 0) {
     // Send out notification so that observers are updated appropriately.
     new_contents->web_contents()->GetController().NotifyEntryChanged(
         new_contents->web_contents()->GetController().GetEntryAtIndex(
             entry_count - 1),
         entry_count - 1);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfile(profile());
   if (session_service) {
     // The new_contents may end up with a different navigation stack. Force
     // the session service to update itself.
-    session_service->TabRestored(
-        new_contents, tab_handler_->GetTabStripModel()->IsTabPinned(index));
+    session_service->TabRestored(new_contents, IsTabPinned(index));
   }
 
   content::DevToolsManager::GetInstance()->TabReplaced(
       old_contents->web_contents(), new_contents->web_contents());
 }
 
 void Browser::TabPinnedStateChanged(TabContentsWrapper* contents, int index) {
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     session_service->SetPinnedState(
         session_id(),
         GetTabContentsWrapperAt(index)->restore_tab_helper()->session_id(),
-        tab_handler_->GetTabStripModel()->IsTabPinned(index));
+        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.
   // NOTE: If you change to be immediate (no invokeLater) then you'll need to
   //       update BrowserList::CloseAllBrowsers.
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&Browser::CloseFrame, weak_factory_.GetWeakPtr()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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 =
-      tabstrip_model()->GetTabContentsAt(
-          tabstrip_model()->GetWrapperIndex(source));
+  nav_params.source_contents = GetTabContentsWrapperAt(
+      tab_handler_->GetTabStripModel()->GetWrapperIndex(source));
   nav_params.referrer = params.referrer;
   nav_params.disposition = params.disposition;
   nav_params.tabstrip_add_types = TabStripModel::ADD_NONE;
   nav_params.window_action = browser::NavigateParams::SHOW_WINDOW;
   nav_params.user_gesture = true;
   nav_params.override_encoding = params.override_encoding;
   nav_params.is_renderer_initiated = params.is_renderer_initiated;
   nav_params.transferred_global_request_id =
       params.transferred_global_request_id;
   browser::Navigate(&nav_params);
@@ skipping 58 matching lines @@
       GetConstrainingContentsWrapper(source_wrapper)->
           blocked_content_tab_helper()->
               AddPopup(new_wrapper, initial_pos, user_gesture);
       return;
     }
 
     new_contents->GetRenderViewHost()->DisassociateFromPopupCount();
   }
 
   browser::NavigateParams params(this, new_wrapper);
-  params.source_contents =
-      source ? tabstrip_model()->GetTabContentsAt(
-                   tabstrip_model()->GetWrapperIndex(source))
-             : NULL;
+  params.source_contents = source ? GetTabContentsWrapperAt(
+      tab_handler_->GetTabStripModel()->GetWrapperIndex(source))
+      : NULL;
   params.disposition = disposition;
   params.window_bounds = initial_pos;
   params.window_action = browser::NavigateParams::SHOW_WINDOW;
   params.user_gesture = user_gesture;
   browser::Navigate(&params);
 }
 
 void Browser::ActivateContents(WebContents* contents) {
-  tab_handler_->GetTabStripModel()->ActivateTabAt(
-      tab_handler_->GetTabStripModel()->GetWrapperIndex(contents), false);
+  ActivateTabAt(tab_handler_->GetTabStripModel()->GetWrapperIndex(contents),
+                false);
   window_->Activate();
 }
 
 void Browser::DeactivateContents(WebContents* contents) {
   window_->Deactivate();
 }
 
 void Browser::LoadingStateChanged(WebContents* source) {
   window_->UpdateLoadingAnimations(
       tab_handler_->GetTabStripModel()->TabsAreLoading());
@@ skipping 243 matching lines @@
 void Browser::ShowPageInfo(content::BrowserContext* browser_context,
                            const GURL& url,
                            const SSLStatus& ssl,
                            bool show_history) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
   window()->ShowPageInfo(profile, url, ssl, show_history);
 }
 
 void Browser::ViewSourceForTab(WebContents* source, const GURL& page_url) {
   DCHECK(source);
-  int index = tabstrip_model()->GetWrapperIndex(source);
-  TabContentsWrapper* wrapper = tabstrip_model()->GetTabContentsAt(index);
+  TabContentsWrapper* wrapper = GetTabContentsWrapperAt(
+      tab_handler_->GetTabStripModel()->GetWrapperIndex(source));
   ViewSource(wrapper);
 }
 
 void Browser::ViewSourceForFrame(WebContents* source,
                                  const GURL& frame_url,
                                  const std::string& frame_content_state) {
   DCHECK(source);
-  int index = tabstrip_model()->GetWrapperIndex(source);
-  TabContentsWrapper* wrapper = tabstrip_model()->GetTabContentsAt(index);
+  TabContentsWrapper* wrapper = GetTabContentsWrapperAt(
+      tab_handler_->GetTabStripModel()->GetWrapperIndex(source));
   ViewSource(wrapper, frame_url, frame_content_state);
 }
 
 bool Browser::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                      bool* is_keyboard_shortcut) {
   // Escape exits tabbed fullscreen mode.
   // TODO(koz): Write a test for this http://crbug.com/100441.
   if (event.windowsKeyCode == 27 &&
       fullscreen_controller_->HandleUserPressedEscape()) {
     return true;
@@ skipping 529 matching lines @@
 void Browser::SwapTabContents(TabContentsWrapper* old_tab_contents,
                               TabContentsWrapper* new_tab_contents) {
   int index =
       tab_handler_->GetTabStripModel()->GetIndexOfTabContents(old_tab_contents);
   DCHECK_NE(TabStripModel::kNoTab, index);
   tab_handler_->GetTabStripModel()->ReplaceTabContentsAt(index,
                                                          new_tab_contents);
 }
 
 void Browser::SetTabContentBlocked(TabContentsWrapper* wrapper, bool blocked) {
-  int index = tabstrip_model()->GetIndexOfTabContents(wrapper);
+  int index = tab_handler_->GetTabStripModel()->GetIndexOfTabContents(wrapper);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED();
     return;
   }
-  tabstrip_model()->SetTabBlocked(index, blocked);
+  tab_handler_->GetTabStripModel()->SetTabBlocked(index, blocked);
   UpdatePrintingState(wrapper->web_contents()->GetContentRestrictions());
 }
 
 void Browser::SetSuggestedText(const string16& text,
                                InstantCompleteBehavior behavior) {
   if (window()->GetLocationBar())
     window()->GetLocationBar()->SetSuggestedText(text, behavior);
 }
 
 gfx::Rect Browser::GetInstantBounds() {
@@ skipping 440 matching lines @@
     // 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_handler_->GetTabStripModel()->UpdateTabContentsStateAt(
-        tab_handler_->GetTabStripModel()->GetIndexOfController(
-            &source->GetController()),
+        GetIndexOfController(&source->GetController()),
         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_handler_->GetTabStripModel()->UpdateTabContentsStateAt(
-        tab_handler_->GetTabStripModel()->GetIndexOfController(
-            &source->GetController()),
+        GetIndexOfController(&source->GetController()),
         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;
 
@@ skipping 104 matching lines @@
       SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     for (int i = index; i < tab_count(); ++i) {
       TabContentsWrapper* tab = GetTabContentsWrapperAt(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(),
-            tab_handler_->GetTabStripModel()->IsTabPinned(i));
+            IsTabPinned(i));
       }
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, OnBeforeUnload handling (private):
 
 void Browser::ProcessPendingTabs() {
   if (!is_attempting_to_close_browser_) {
@@ skipping 178 matching lines @@
         location_bar->SaveStateToContents(contents->web_contents());
     }
 
     if (!tab_handler_->GetTabStripModel()->closing_all())
       SyncHistoryWithTabs(0);
   }
 
   SetAsDelegate(contents, NULL);
   RemoveScheduledUpdatesFor(contents->web_contents());
 
-  if (find_bar_controller_.get() &&
-      index == tab_handler_->GetTabStripModel()->active_index()) {
+  if (find_bar_controller_.get() && index == active_index()) {
     find_bar_controller_->ChangeTabContents(NULL);
   }
 
   if (is_attempting_to_close_browser_) {
     // If this is the last tab with unload handlers, then ProcessPendingTabs
     // would call back into the TabStripModel (which is invoking this method on
     // us). Avoid that by passing in false so that the call to
     // ProcessPendingTabs is delayed.
     ClearUnloadState(contents->web_contents(), false);
   }
@@ skipping 130 matching lines @@
   active_entry->SetContentState(
       webkit_glue::RemoveScrollOffsetFromHistoryState(content_state));
 
   // Do not restore title, derive it from the url.
   active_entry->SetTitle(string16());
 
   // Now show view-source entry.
   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_handler_->GetTabStripModel()->
-        GetIndexOfTabContents(contents);
+    int index =
+        tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents);
     int add_types = TabStripModel::ADD_ACTIVE |
         TabStripModel::ADD_INHERIT_GROUP;
     tab_handler_->GetTabStripModel()->InsertTabContentsAt(index + 1,
                                                           view_source_contents,
                                                           add_types);
   } else {
     Browser* browser = Browser::CreateForType(TYPE_TABBED, 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.
@@ skipping 73 matching lines @@
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           profile()->GetOriginalProfile());
   if (service->HasSyncSetupCompleted())
     ShowOptionsTab(chrome::kPersonalOptionsSubPage);
   else
     service->ShowLoginDialog();
 }
 
 void Browser::ToggleSpeechInput() {
-  GetSelectedTabContentsWrapper()->web_contents()->GetRenderViewHost()->
-      ToggleSpeechInput();
+  GetSelectedWebContents()->GetRenderViewHost()->ToggleSpeechInput();
 }
 
 void Browser::OnWindowDidShow() {
   if (window_has_shown_)
     return;
   window_has_shown_ = true;
 
   // Nothing to do for non-tabbed windows.
   if (!is_type_tabbed())
     return;
@@ skipping 10 matching lines @@
     local_state->SetBoolean(prefs::kShouldShowFirstRunBubble, false);
     window_->GetLocationBar()->ShowFirstRunBubble();
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error)
       error->ShowBubbleView(this);
   }
 }