Rename TabContents::controller() to GetController and put it into the WebContents interface.

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 1285 matching lines @@
       profile(),
       tab_util::GetSiteInstanceForNewTab(NULL, profile_, restore_url),
       MSG_ROUTING_NONE,
       GetSelectedTabContents(),
       session_storage_namespace);
   TabContents* new_tab = wrapper->tab_contents();
   wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
   std::vector<NavigationEntry*> entries;
   TabNavigation::CreateNavigationEntriesFromTabNavigations(
       profile_, navigations, &entries);
-  new_tab->controller().Restore(
+  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());
     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
     // anchor link location calculations to be incorrect even after a new
     // layout with proper view dimensions. TabStripModel::AddTabContents()
     // contains similar logic.
     new_tab->view()->SizeContents(window_->GetRestoredBounds().size());
     new_tab->HideContents();
-    new_tab->controller().LoadIfNecessary();
+    new_tab->GetController().LoadIfNecessary();
   }
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(wrapper, pin);
   return new_tab;
 }
 
 void Browser::ReplaceRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int selected_navigation,
     bool from_last_session,
     const std::string& extension_app_id,
     SessionStorageNamespace* session_storage_namespace) {
   GURL restore_url = navigations.at(selected_navigation).virtual_url();
   TabContentsWrapper* wrapper = TabContentsFactory(
       profile(),
       tab_util::GetSiteInstanceForNewTab(NULL, profile_, restore_url),
       MSG_ROUTING_NONE,
       GetSelectedTabContents(),
       session_storage_namespace);
   wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
   TabContents* replacement = wrapper->tab_contents();
   std::vector<NavigationEntry*> entries;
   TabNavigation::CreateNavigationEntriesFromTabNavigations(
       profile_, navigations, &entries);
-  replacement->controller().Restore(
+  replacement->GetController().Restore(
       selected_navigation, from_last_session, &entries);
   DCHECK_EQ(0u, entries.size());
 
   tab_handler_->GetTabStripModel()->ReplaceNavigationControllerAt(
       tab_handler_->GetTabStripModel()->active_index(),
       wrapper);
 }
 
 bool Browser::CanRestoreTab() {
   return command_updater_.IsCommandEnabled(IDC_RESTORE_TAB);
 }
 
 bool Browser::NavigateToIndexWithDisposition(int index,
                                              WindowOpenDisposition disp) {
   NavigationController& controller =
-      GetOrCloneTabForDisposition(disp)->controller();
+      GetOrCloneTabForDisposition(disp)->GetController();
   if (index < 0 || index >= controller.entry_count())
     return false;
   controller.GoToIndex(index);
   return true;
 }
 
 browser::NavigateParams Browser::GetSingletonTabNavigateParams(
     const GURL& url) {
   browser::NavigateParams params(
       this, url, content::PAGE_TRANSITION_AUTO_BOOKMARK);
@@ skipping 108 matching lines @@
   TabCloseableStateWatcher* watcher =
       g_browser_process->tab_closeable_state_watcher();
   bool can_close = !watcher || watcher->CanCloseBrowser(this);
   if (!can_close && is_attempting_to_close_browser_)
     CancelWindowClose();
   return can_close;
 }
 
 bool Browser::CanGoBack() const {
   return GetSelectedTabContentsWrapper()->
-      tab_contents()->controller().CanGoBack();
+      tab_contents()->GetController().CanGoBack();
 }
 
 void Browser::GoBack(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Back"));
 
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   if (CanGoBack()) {
     TabContents* new_tab = GetOrCloneTabForDisposition(disposition);
     // If we are on an interstitial page and clone the tab, it won't be copied
     // to the new tab, so we don't need to go back.
     if (current_tab->tab_contents()->showing_interstitial_page() &&
         (new_tab != current_tab->tab_contents()))
       return;
-    new_tab->controller().GoBack();
+    new_tab->GetController().GoBack();
   }
 }
 
 bool Browser::CanGoForward() const {
   return GetSelectedTabContentsWrapper()->
-      tab_contents()->controller().CanGoForward();
+      tab_contents()->GetController().CanGoForward();
 }
 
 void Browser::GoForward(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward())
-    GetOrCloneTabForDisposition(disposition)->controller().GoForward();
+    GetOrCloneTabForDisposition(disposition)->GetController().GoForward();
 }
 
 void Browser::Reload(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Reload"));
   ReloadInternal(disposition, false);
 }
 
 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();
   if (current_tab && current_tab->showing_interstitial_page()) {
-    NavigationEntry* entry = current_tab->controller().GetActiveEntry();
+    NavigationEntry* entry = current_tab->GetController().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
     OpenURL(entry->url(), GURL(), disposition, content::PAGE_TRANSITION_RELOAD);
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
   TabContents* tab = GetOrCloneTabForDisposition(disposition);
   if (!tab->FocusLocationBarByDefault())
     tab->Focus();
   if (ignore_cache)
-    tab->controller().ReloadIgnoringCache(true);
+    tab->GetController().ReloadIgnoringCache(true);
   else
-    tab->controller().Reload(true);
+    tab->GetController().Reload(true);
 }
 
 void Browser::Home(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Home"));
   OpenURL(
       profile_->GetHomePage(), GURL(), disposition,
       content::PageTransitionFromInt(
           content::PAGE_TRANSITION_AUTO_BOOKMARK |
           content::PAGE_TRANSITION_HOME_PAGE));
 }
@@ skipping 483 matching lines @@
 
 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.";
 
   NavigationEntry* entry =
-      current_tab->tab_contents()->controller().GetLastCommittedEntry();
+      current_tab->tab_contents()->GetController().GetLastCommittedEntry();
   if (!entry)
     return;
 
   // RVH's GetApplicationInfo should not be called before it returns.
   DCHECK(pending_web_app_action_ == NONE);
   pending_web_app_action_ = CREATE_SHORTCUT;
 
   // Start fetching web app info for CreateApplicationShortcut dialog and show
   // the dialog when the data is available in OnDidGetApplicationInfo.
   current_tab->extension_tab_helper()->GetApplicationInfo(entry->page_id());
@@ skipping 93 matching lines @@
 }
 
 void Browser::ShowAboutConflictsTab() {
   content::RecordAction(UserMetricsAction("AboutConflicts"));
   ShowSingletonTab(GURL(chrome::kChromeUIConflictsURL));
 }
 
 void Browser::ShowBrokenPageTab(TabContents* contents) {
   content::RecordAction(UserMetricsAction("ReportBug"));
   string16 page_title = contents->GetTitle();
-  NavigationEntry* entry = contents->controller().GetActiveEntry();
+  NavigationEntry* entry = contents->GetController().GetActiveEntry();
   if (!entry)
     return;
   std::string page_url = entry->url().spec();
   std::vector<std::string> subst;
   subst.push_back(UTF16ToASCII(page_title));
   subst.push_back(page_url);
   std::string report_page_url =
       ReplaceStringPlaceholders(kBrokenPageUrl, subst, NULL);
   ShowSingletonTab(GURL(report_page_url));
 }
@@ skipping 899 matching lines @@
 TabContentsWrapper* Browser::CreateTabContentsForURL(
     const GURL& url, const content::Referrer& referrer, Profile* profile,
     content::PageTransition transition, bool defer_load,
     SiteInstance* instance) const {
   TabContentsWrapper* contents = TabContentsFactory(profile, instance,
       MSG_ROUTING_NONE,
       GetSelectedTabContents(), NULL);
   if (!defer_load) {
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
-    contents->tab_contents()->controller().LoadURL(
+    contents->tab_contents()->GetController().LoadURL(
         url, referrer, transition, std::string());
   }
 
   return contents;
 }
 
 bool Browser::CanDuplicateContentsAt(int index) {
-  NavigationController& nc = GetTabContentsAt(index)->controller();
+  NavigationController& nc = GetTabContentsAt(index)->GetController();
   return nc.tab_contents() && nc.GetLastCommittedEntry();
 }
 
 void Browser::DuplicateContentsAt(int index) {
   TabContentsWrapper* contents = GetTabContentsWrapperAt(index);
   CHECK(contents);
   TabContentsWrapper* contents_dupe = contents->Clone();
 
   bool pinned = false;
   if (CanSupportWindowFeature(FEATURE_TABSTRIP)) {
@@ skipping 58 matching lines @@
 
   // We don't create historical tabs for print preview tabs.
   if (contents->tab_contents()->GetURL() == GURL(chrome::kChromeUIPrintURL))
     return;
 
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile());
 
   // We only create historical tab entries for tabbed browser windows.
   if (service && CanSupportWindowFeature(FEATURE_TABSTRIP)) {
-    service->CreateHistoricalTab(&contents->tab_contents()->controller(),
+    service->CreateHistoricalTab(&contents->tab_contents()->GetController(),
         tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents));
   }
 }
 
 bool Browser::RunUnloadListenerBeforeClosing(TabContentsWrapper* contents) {
   return Browser::RunUnloadEventsHelper(contents->tab_contents());
 }
 
 bool Browser::CanReloadContents(TabContents* source) const {
   return !is_devtools();
@@ skipping 68 matching lines @@
                  content::Source<TabContents>(contents->tab_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContentsWrapper* contents,
                            int index) {
   fullscreen_controller_->OnTabClosing(contents->tab_contents());
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(
-          &contents->tab_contents()->controller()),
+          &contents->tab_contents()->GetController()),
       content::NotificationService::NoDetails());
 
   // Sever the TabContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
 void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
 
@@ skipping 77 matching lines @@
 }
 
 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()));
 
-  int entry_count = new_contents->tab_contents()->controller().entry_count();
+  int entry_count = new_contents->tab_contents()->GetController().entry_count();
   if (entry_count > 0) {
     // Send out notification so that observers are updated appropriately.
-    new_contents->tab_contents()->controller().NotifyEntryChanged(
-        new_contents->tab_contents()->controller().GetEntryAtIndex(
+    new_contents->tab_contents()->GetController().NotifyEntryChanged(
+        new_contents->tab_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(
@@ skipping 147 matching lines @@
     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
       // 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->controller().GetLastCommittedEntry();
+      NavigationEntry* entry = source->GetController().GetLastCommittedEntry();
       if (entry) {
         TabContentsWrapper::GetCurrentWrapperForContents(source)->
             extension_tab_helper()->GetApplicationInfo(entry->page_id());
       } else {
         pending_web_app_action_ = NONE;
       }
     }
   }
 }
 
@@ skipping 80 matching lines @@
       content::Source<Browser>(this),
       content::NotificationService::NoDetails());
   return false;
 }
 
 bool Browser::IsApplication() const {
   return is_app();
 }
 
 void Browser::ConvertContentsToApplication(TabContents* contents) {
-  const GURL& url = contents->controller().GetActiveEntry()->url();
+  const GURL& url = contents->GetController().GetActiveEntry()->url();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
 
   DetachContents(contents);
   Browser* app_browser = Browser::CreateForApp(
       TYPE_POPUP, app_name, gfx::Rect(), profile_);
   TabContentsWrapper* wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(contents);
   if (!wrapper)
     wrapper = new TabContentsWrapper(contents);
   app_browser->tabstrip_model()->AppendTabContents(wrapper, true);
@@ skipping 97 matching lines @@
     if ((download->GetTotalBytes() > 0) &&
         !ChromeDownloadManagerDelegate::IsExtensionDownload(download) &&
         platform_util::IsVisible(shelf_tab->GetNativeView()) &&
         ui::Animation::ShouldRenderRichAnimation()) {
       DownloadStartedAnimation::Show(shelf_tab);
     }
 #endif
   }
 
   // If the download occurs in a new tab, close it.
-  if (source->controller().IsInitialNavigation() && tab_count() > 1)
+  if (source->GetController().IsInitialNavigation() && tab_count() > 1)
     CloseContents(source);
 }
 
 void Browser::ShowPageInfo(content::BrowserContext* browser_context,
                            const GURL& url,
                            const NavigationEntry::SSLStatus& ssl,
                            bool show_history) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
   window()->ShowPageInfo(profile, url, ssl, show_history);
 }
@@ skipping 204 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CoreTabHelperDelegate implementation:
 
 void Browser::OnDidGetApplicationInfo(TabContentsWrapper* source,
                                       int32 page_id) {
   if (GetSelectedTabContentsWrapper() != source)
     return;
 
   NavigationEntry* entry =
-      source->tab_contents()->controller().GetLastCommittedEntry();
+      source->tab_contents()->GetController().GetLastCommittedEntry();
   if (!entry || (entry->page_id() != page_id))
     return;
 
   switch (pending_web_app_action_) {
     case CREATE_SHORTCUT: {
       window()->ShowCreateWebAppShortcutsDialog(source);
       break;
     }
     case UPDATE_SHORTCUT: {
       web_app::UpdateShortcutForTabContents(source);
@@ skipping 90 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()->controller() ==
+          &GetSelectedTabContents()->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 453 matching lines @@
   UpdateCommandsForBookmarkBar();
 }
 
 void Browser::UpdateCommandsForTabState() {
   TabContents* current_tab = GetSelectedTabContents();
   TabContentsWrapper* current_tab_wrapper = GetSelectedTabContentsWrapper();
   if (!current_tab || !current_tab_wrapper)  // May be NULL during tab restore.
     return;
 
   // Navigation commands
-  NavigationController& nc = current_tab->controller();
+  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));
   command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE,
                                         CanReloadContents(current_tab));
 
   // Window management commands
   command_updater_.UpdateCommandEnabled(IDC_DUPLICATE_TAB,
       !is_app() && CanDuplicateContentsAt(active_index()));
 
   // Page-related commands
   window_->SetStarredState(
       current_tab_wrapper->bookmark_tab_helper()->is_starred());
   command_updater_.UpdateCommandEnabled(IDC_VIEW_SOURCE,
-      current_tab->controller().CanViewSource());
+      current_tab->GetController().CanViewSource());
   command_updater_.UpdateCommandEnabled(IDC_EMAIL_PAGE_LOCATION,
       toolbar_model_.ShouldDisplayURL() && current_tab->GetURL().is_valid());
   if (is_devtools())
       command_updater_.UpdateCommandEnabled(IDC_OPEN_FILE, false);
 
   // Changing the encoding is not possible on Chrome-internal webpages.
   bool is_chrome_internal = HasInternalURL(nc.GetActiveEntry());
   command_updater_.UpdateCommandEnabled(IDC_ENCODING_MENU,
       !is_chrome_internal && SavePackage::IsSavableContents(
           current_tab->contents_mime_type()));
@@ skipping 134 matching lines @@
     // 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.
     tab_handler_->GetTabStripModel()->UpdateTabContentsStateAt(
         tab_handler_->GetTabStripModel()->GetIndexOfController(
-            &source->controller()),
+            &source->GetController()),
         TabStripModelObserver::LOADING_ONLY);
     // The status bubble needs to be updated during INVALIDATE_LOAD too, but
     // we do that asynchronously by not stripping INVALIDATE_LOAD from
     // changed_flags.
   }
 
   if (changed_flags & TabContents::INVALIDATE_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->controller()),
+            &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 385 matching lines @@
             INSTANT_COMMIT_PRESSED_ENTER)),
         content::NotificationService::NoDetails());
     return true;
   }
   if (disposition == NEW_FOREGROUND_TAB) {
     TabContentsWrapper* preview_contents = instant()->ReleasePreviewContents(
         INSTANT_COMMIT_PRESSED_ENTER);
     // HideInstant is invoked after release so that InstantController is not
     // active when HideInstant asks it for its state.
     HideInstant();
-    preview_contents->tab_contents()->controller().PruneAllButActive();
+    preview_contents->tab_contents()->GetController().PruneAllButActive();
     tab_handler_->GetTabStripModel()->AddTabContents(
         preview_contents,
         -1,
         instant()->last_transition_type(),
         TabStripModel::ADD_ACTIVE);
     instant()->CompleteRelease(preview_contents);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_COMMITTED,
         content::Source<TabContentsWrapper>(preview_contents),
         content::NotificationService::NoDetails());
@@ skipping 11 matching lines @@
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(profile_, this));
     instant_unload_handler_.reset(new InstantUnloadHandler(this));
   }
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents) {
   DCHECK(contents);
 
   NavigationEntry* active_entry =
-      contents->tab_contents()->controller().GetActiveEntry();
+      contents->tab_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   ViewSource(contents, active_entry->url(), active_entry->content_state());
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents,
                          const GURL& url,
                          const std::string& content_state) {
   content::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
   TabContentsWrapper* view_source_contents = contents->Clone();
-  view_source_contents->tab_contents()->controller().PruneAllButActive();
+  view_source_contents->tab_contents()->GetController().PruneAllButActive();
   NavigationEntry* active_entry =
-      view_source_contents->tab_contents()->controller().GetActiveEntry();
+      view_source_contents->tab_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   GURL view_source_url = GURL(chrome::kViewSourceScheme + std::string(":") +
       url.spec());
   active_entry->set_virtual_url(view_source_url);
 
   // Do not restore scroller position.
   active_entry->set_content_state(
       webkit_glue::RemoveScrollOffsetFromHistoryState(content_state));
@@ skipping 33 matching lines @@
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
 }
 
 int Browser::GetContentRestrictionsForSelectedTab() {
   int content_restrictions = 0;
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab) {
     content_restrictions = current_tab->content_restrictions();
-    NavigationEntry* active_entry = current_tab->controller().GetActiveEntry();
+    NavigationEntry* active_entry =
+        current_tab->GetController().GetActiveEntry();
     // See comment in UpdateCommandsForTabState about why we call url().
     if (!SavePackage::IsSavableURL(active_entry ? active_entry->url() : GURL()))
       content_restrictions |= content::CONTENT_RESTRICTION_SAVE;
   }
   return content_restrictions;
 }
 
 void Browser::UpdateBookmarkBarState(BookmarkBarStateChangeReason reason) {
   BookmarkBar::State state;
   // The bookmark bar is hidden in fullscreen mode, unless on the new tab page.
@@ skipping 79 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }