TabContents -> WebContentsImpl, part 12.

content/browser/web_contents/navigation_controller_impl.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 "content/browser/web_contents/navigation_controller_impl.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"  // Temporary
 #include "base/string_util.h"
@@ skipping 130 matching lines @@
   // remove "view-source:" from the beginning of the URL to get the URL that
   // will actually be loaded. This real URL won't be shown to the user, just
   // used internally.
   GURL loaded_url(url);
   bool reverse_on_redirect = false;
   BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
       &loaded_url, browser_context, &reverse_on_redirect);
 
   NavigationEntryImpl* entry = new NavigationEntryImpl(
       NULL,  // The site instance for tabs is sent on navigation
-             // (TabContents::GetSiteInstance).
+             // (WebContents::GetSiteInstance).
       -1,
       loaded_url,
       referrer,
       string16(),
       transition,
       is_renderer_initiated);
   entry->SetVirtualURL(url);
   entry->set_user_typed_url(url);
   entry->set_update_virtual_url_with_url(reverse_on_redirect);
   entry->set_extra_headers(extra_headers);
   return entry;
 }
 
 // static
 void NavigationController::DisablePromptOnRepost() {
   g_check_for_repost = false;
 }
 
 }  // namespace content
 
 NavigationControllerImpl::NavigationControllerImpl(
-    TabContents* contents,
+    WebContentsImpl* web_contents,
     BrowserContext* browser_context,
     SessionStorageNamespaceImpl* session_storage_namespace)
     : browser_context_(browser_context),
       pending_entry_(NULL),
       last_committed_entry_index_(-1),
       pending_entry_index_(-1),
       transient_entry_index_(-1),
-      tab_contents_(contents),
+      web_contents_(web_contents),
       max_restored_page_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(ssl_manager_(this)),
       needs_reload_(false),
       session_storage_namespace_(session_storage_namespace),
       pending_reload_(NO_RELOAD) {
   DCHECK(browser_context_);
   if (!session_storage_namespace_) {
     session_storage_namespace_ = new SessionStorageNamespaceImpl(
         static_cast<DOMStorageContextImpl*>(
             BrowserContext::GetDOMStorageContext(browser_context_)));
   }
 }
 
 NavigationControllerImpl::~NavigationControllerImpl() {
   DiscardNonCommittedEntriesInternal();
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSED,
       content::Source<NavigationController>(this),
       content::NotificationService::NoDetails());
 }
 
 WebContents* NavigationControllerImpl::GetWebContents() const {
-  return tab_contents_;
+  return web_contents_;
 }
 
 BrowserContext* NavigationControllerImpl::GetBrowserContext() const {
   return browser_context_;
 }
 
 void NavigationControllerImpl::SetBrowserContext(
     BrowserContext* browser_context) {
   browser_context_ = browser_context;
 }
@@ skipping 44 matching lines @@
       GetEntryAtIndex(current_index)->GetHasPostData()) {
     // The user is asking to reload a page with POST data. Prompt to make sure
     // they really want to do this. If they do, the dialog will call us back
     // with check_for_repost = false.
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_REPOST_WARNING_SHOWN,
         content::Source<NavigationController>(this),
         content::NotificationService::NoDetails());
 
     pending_reload_ = reload_type;
-    tab_contents_->Activate();
-    tab_contents_->GetDelegate()->ShowRepostFormWarningDialog(tab_contents_);
+    web_contents_->Activate();
+    web_contents_->GetDelegate()->ShowRepostFormWarningDialog(web_contents_);
   } else {
     DiscardNonCommittedEntriesInternal();
 
     NavigationEntryImpl* entry = entries_[current_index].get();
     SiteInstanceImpl* site_instance = entry->site_instance();
     DCHECK(site_instance);
 
     // If we are reloading an entry that no longer belongs to the current
     // site instance (for example, refreshing a page for just installed app),
     // the reload must happen in a new process.
@@ skipping 116 matching lines @@
 }
 
 NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const {
   if (last_committed_entry_index_ == -1)
     return NULL;
   return entries_[last_committed_entry_index_].get();
 }
 
 bool NavigationControllerImpl::CanViewSource() const {
   bool is_supported_mime_type = net::IsSupportedNonImageMimeType(
-      tab_contents_->GetContentsMimeType().c_str());
+      web_contents_->GetContentsMimeType().c_str());
   NavigationEntry* active_entry = GetActiveEntry();
   return active_entry && !active_entry->IsViewSourceMode() &&
-    is_supported_mime_type && !tab_contents_->GetInterstitialPage();
+    is_supported_mime_type && !web_contents_->GetInterstitialPage();
 }
 
 int NavigationControllerImpl::GetLastCommittedEntryIndex() const {
   return last_committed_entry_index_;
 }
 
 int NavigationControllerImpl::GetEntryCount() const {
   DCHECK(entries_.size() <= max_entry_count());
   return static_cast<int>(entries_.size());
 }
@@ skipping 123 matching lines @@
 
 void NavigationControllerImpl::AddTransientEntry(NavigationEntryImpl* entry) {
   // Discard any current transient entry, we can only have one at a time.
   int index = 0;
   if (last_committed_entry_index_ != -1)
     index = last_committed_entry_index_ + 1;
   DiscardTransientEntry();
   entries_.insert(
       entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
   transient_entry_index_ = index;
-  tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
+  web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 }
 
 void NavigationControllerImpl::TransferURL(
     const GURL& url,
     const content::Referrer& referrer,
     content::PageTransition transition,
     const std::string& extra_headers,
     const GlobalRequestID& transferred_global_request_id,
     bool is_renderer_initiated) {
   // The user initiated a load, we don't need to reload anymore.
@@ skipping 96 matching lines @@
       if (!RendererDidNavigateAutoSubframe(params))
         return false;
       break;
     case content::NAVIGATION_TYPE_NAV_IGNORE:
       // If a pending navigation was in progress, this canceled it.  We should
       // discard it and make sure it is removed from the URL bar.  After that,
       // there is nothing we can do with this navigation, so we just return to
       // the caller that nothing has happened.
       if (pending_entry_) {
         DiscardNonCommittedEntries();
-        tab_contents_->NotifyNavigationStateChanged(
+        web_contents_->NotifyNavigationStateChanged(
             content::INVALIDATE_TYPE_URL);
       }
       return false;
     default:
       NOTREACHED();
   }
 
   // All committed entries should have nonempty content state so WebKit doesn't
   // get confused when we go back to them (see the function for details).
   DCHECK(!params.content_state.empty());
   NavigationEntryImpl* active_entry =
       NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
   active_entry->SetContentState(params.content_state);
 
   // Once committed, we do not need to track if the entry was initiated by
   // the renderer.
   active_entry->set_is_renderer_initiated(false);
 
   // The active entry's SiteInstance should match our SiteInstance.
-  DCHECK(active_entry->site_instance() == tab_contents_->GetSiteInstance());
+  DCHECK(active_entry->site_instance() == web_contents_->GetSiteInstance());
 
   // Now prep the rest of the details for the notification and broadcast.
   details->entry = active_entry;
   details->is_main_frame =
       content::PageTransitionIsMainFrame(params.transition);
   details->serialized_security_info = params.security_info;
   details->http_status_code = params.http_status_code;
   NotifyNavigationEntryCommitted(details);
 
   return true;
@@ skipping 16 matching lines @@
     //   could be invalid. This can also happen for a cross-site transition
     //   that causes us to swap processes. Then the error page load will be in
     //   a new process with no page IDs ever assigned (and hence a -1 value),
     //   yet the navigation controller still might have previous pages in its
     //   list.
     //
     // In these cases, there's nothing we can do with them, so ignore.
     return content::NAVIGATION_TYPE_NAV_IGNORE;
   }
 
-  if (params.page_id > tab_contents_->GetMaxPageID()) {
+  if (params.page_id > web_contents_->GetMaxPageID()) {
     // Greater page IDs than we've ever seen before are new pages. We may or may
     // not have a pending entry for the page, and this may or may not be the
     // main frame.
     if (content::PageTransitionIsMainFrame(params.transition))
       return content::NAVIGATION_TYPE_NEW_PAGE;
 
     // When this is a new subframe navigation, we should have a committed page
     // for which it's a suframe in. This may not be the case when an iframe is
     // navigated on a popup navigated to about:blank (the iframe would be
     // written into the popup by script on the main page). For these cases,
     // there isn't any navigation stuff we can do, so just ignore it.
     if (!GetLastCommittedEntry())
       return content::NAVIGATION_TYPE_NAV_IGNORE;
 
     // Valid subframe navigation.
     return content::NAVIGATION_TYPE_NEW_SUBFRAME;
   }
 
   // Now we know that the notification is for an existing page. Find that entry.
   int existing_entry_index = GetEntryIndexWithPageID(
-      tab_contents_->GetSiteInstance(),
+      web_contents_->GetSiteInstance(),
       params.page_id);
   if (existing_entry_index == -1) {
     // The page was not found. It could have been pruned because of the limit on
     // back/forward entries (not likely since we'll usually tell it to navigate
     // to such entries). It could also mean that the renderer is smoking crack.
     NOTREACHED();
 
     // Because the unknown entry has committed, we risk showing the wrong URL in
     // release builds. Instead, we'll kill the renderer process to be safe.
     LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
     content::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
 
     // Temporary code so we can get more information.  Format:
     //  http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
     std::string temp = params.url.spec();
     temp.append("#page");
     temp.append(base::IntToString(params.page_id));
     temp.append("#max");
-    temp.append(base::IntToString(tab_contents_->GetMaxPageID()));
+    temp.append(base::IntToString(web_contents_->GetMaxPageID()));
     temp.append("#frame");
     temp.append(base::IntToString(params.frame_id));
     temp.append("#ids");
     for (int i = 0; i < static_cast<int>(entries_.size()); ++i) {
       // Append entry metadata (e.g., 3_7x):
       //  3: page_id
       //  7: SiteInstance ID, or N for null
       //  x: appended if not from the current SiteInstance
       temp.append(base::IntToString(entries_[i]->GetPageID()));
       temp.append("_");
       if (entries_[i]->site_instance())
         temp.append(base::IntToString(entries_[i]->site_instance()->GetId()));
       else
         temp.append("N");
-      if (entries_[i]->site_instance() != tab_contents_->GetSiteInstance())
+      if (entries_[i]->site_instance() != web_contents_->GetSiteInstance())
         temp.append("x");
       temp.append(",");
     }
     GURL url(temp);
     static_cast<RenderViewHostImpl*>(
-        tab_contents_->GetRenderViewHost())->Send(
+        web_contents_->GetRenderViewHost())->Send(
             new ViewMsg_TempCrashWithData(url));
     return content::NAVIGATION_TYPE_NAV_IGNORE;
   }
   NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
 
   if (!content::PageTransitionIsMainFrame(params.transition)) {
     // All manual subframes would get new IDs and were handled above, so we
     // know this is auto. Since the current page was found in the navigation
     // entry list, we're guaranteed to have a last committed entry.
     DCHECK(GetLastCommittedEntry());
@@ skipping 62 matching lines @@
     update_virtual_url = true;
   }
 
   new_entry->SetURL(params.url);
   if (update_virtual_url)
     UpdateVirtualURLToURL(new_entry, params.url);
   new_entry->SetReferrer(params.referrer);
   new_entry->SetPageID(params.page_id);
   new_entry->SetTransitionType(params.transition);
   new_entry->set_site_instance(
-      static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
+      static_cast<SiteInstanceImpl*>(web_contents_->GetSiteInstance()));
   new_entry->SetHasPostData(params.is_post);
   new_entry->SetPostID(params.post_id);
 
   InsertOrReplaceEntry(new_entry, *did_replace_entry);
 }
 
 void NavigationControllerImpl::RendererDidNavigateToExistingPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // We should only get here for main frame navigations.
   DCHECK(content::PageTransitionIsMainFrame(params.transition));
 
   // This is a back/forward navigation. The existing page for the ID is
   // guaranteed to exist by ClassifyNavigation, and we just need to update it
   // with new information from the renderer.
-  int entry_index = GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(),
+  int entry_index = GetEntryIndexWithPageID(web_contents_->GetSiteInstance(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
   NavigationEntryImpl* entry = entries_[entry_index].get();
 
   // The URL may have changed due to redirects. The site instance will normally
   // be the same except during session restore, when no site instance will be
   // assigned.
   entry->SetURL(params.url);
   if (entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(entry, params.url);
   DCHECK(entry->site_instance() == NULL ||
-         entry->site_instance() == tab_contents_->GetSiteInstance());
+         entry->site_instance() == web_contents_->GetSiteInstance());
   entry->set_site_instance(
-      static_cast<SiteInstanceImpl*>(tab_contents_->GetSiteInstance()));
+      static_cast<SiteInstanceImpl*>(web_contents_->GetSiteInstance()));
 
   entry->SetHasPostData(params.is_post);
   entry->SetPostID(params.post_id);
 
   // The entry we found in the list might be pending if the user hit
   // back/forward/reload. This load should commit it (since it's already in the
   // list, we can just discard the pending pointer).  We should also discard the
   // pending entry if it corresponds to a different navigation, since that one
   // is now likely canceled.  If it is not canceled, we will treat it as a new
   // navigation when it arrives, which is also ok.
   //
   // Note that we need to use the "internal" version since we don't want to
   // actually change any other state, just kill the pointer.
   if (pending_entry_)
     DiscardNonCommittedEntriesInternal();
 
   // If a transient entry was removed, the indices might have changed, so we
   // have to query the entry index again.
   last_committed_entry_index_ =
-      GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
+      GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
 }
 
 void NavigationControllerImpl::RendererDidNavigateToSamePage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // This mode implies we have a pending entry that's the same as an existing
   // entry for this page ID. This entry is guaranteed to exist by
   // ClassifyNavigation. All we need to do is update the existing entry.
   NavigationEntryImpl* existing_entry = GetEntryWithPageID(
-      tab_contents_->GetSiteInstance(), params.page_id);
+      web_contents_->GetSiteInstance(), params.page_id);
 
   // We assign the entry's unique ID to be that of the new one. Since this is
   // always the result of a user action, we want to dismiss infobars, etc. like
   // a regular user-initiated navigation.
   existing_entry->set_unique_id(pending_entry_->GetUniqueID());
 
   // The URL may have changed due to redirects.
   if (existing_entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(existing_entry, params.url);
   existing_entry->SetURL(params.url);
 
   DiscardNonCommittedEntries();
 }
 
 void NavigationControllerImpl::RendererDidNavigateInPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
   DCHECK(content::PageTransitionIsMainFrame(params.transition)) <<
       "WebKit should only tell us about in-page navs for the main frame.";
   // We're guaranteed to have an entry for this one.
   NavigationEntryImpl* existing_entry = GetEntryWithPageID(
-      tab_contents_->GetSiteInstance(), params.page_id);
+      web_contents_->GetSiteInstance(), params.page_id);
 
   // Reference fragment navigation. We're guaranteed to have the last_committed
   // entry and it will be the same page as the new navigation (minus the
   // reference fragments, of course).  We'll update the URL of the existing
   // entry without pruning the forward history.
   existing_entry->SetURL(params.url);
   if (existing_entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(existing_entry, params.url);
 
   // This replaces the existing entry since the page ID didn't change.
   *did_replace_entry = true;
 
   if (pending_entry_)
     DiscardNonCommittedEntriesInternal();
 
   // If a transient entry was removed, the indices might have changed, so we
   // have to query the entry index again.
   last_committed_entry_index_ =
-      GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
+      GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
 }
 
 void NavigationControllerImpl::RendererDidNavigateNewSubframe(
     const ViewHostMsg_FrameNavigate_Params& params) {
   if (content::PageTransitionStripQualifier(params.transition) ==
       content::PAGE_TRANSITION_AUTO_SUBFRAME) {
     // This is not user-initiated. Ignore.
     return;
   }
 
@@ skipping 12 matching lines @@
 bool NavigationControllerImpl::RendererDidNavigateAutoSubframe(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // We're guaranteed to have a previously committed entry, and we now need to
   // handle navigation inside of a subframe in it without creating a new entry.
   DCHECK(GetLastCommittedEntry());
 
   // Handle the case where we're navigating back/forward to a previous subframe
   // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the
   // header file. In case "1." this will be a NOP.
   int entry_index = GetEntryIndexWithPageID(
-      tab_contents_->GetSiteInstance(),
+      web_contents_->GetSiteInstance(),
       params.page_id);
   if (entry_index < 0 ||
       entry_index >= static_cast<int>(entries_.size())) {
     NOTREACHED();
     return false;
   }
 
   // Update the current navigation entry in case we're going back/forward.
   if (entry_index != last_committed_entry_index_) {
     last_committed_entry_index_ = entry_index;
@@ skipping 31 matching lines @@
   needs_reload_ = true;
   InsertEntriesFrom(source, source.GetEntryCount());
 
   session_storage_namespace_ = source.session_storage_namespace_->Clone();
 
   FinishRestore(source.last_committed_entry_index_, false);
 
   // Copy the max page id map from the old tab to the new tab.  This ensures
   // that new and existing navigations in the tab's current SiteInstances
   // are identified properly.
-  tab_contents_->CopyMaxPageIDsFrom(source.tab_contents());
+  web_contents_->CopyMaxPageIDsFrom(source.web_contents());
 }
 
 void NavigationControllerImpl::CopyStateFromAndPrune(
     NavigationController* temp) {
   NavigationControllerImpl* source =
       static_cast<NavigationControllerImpl*>(temp);
   // The SiteInstance and page_id of the last committed entry needs to be
   // remembered at this point, in case there is only one committed entry
   // and it is pruned.  We use a scoped_refptr to ensure the SiteInstance
   // can't be freed during this time period.
   NavigationEntryImpl* last_committed =
       NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
   scoped_refptr<SiteInstance> site_instance(
       last_committed ? last_committed->site_instance() : NULL);
   int32 minimum_page_id = last_committed ? last_committed->GetPageID() : -1;
   int32 max_page_id = last_committed ?
-      tab_contents_->GetMaxPageIDForSiteInstance(site_instance.get()) : -1;
+      web_contents_->GetMaxPageIDForSiteInstance(site_instance.get()) : -1;
 
   // This code is intended for use when the last entry is the active entry.
   DCHECK(
       (transient_entry_index_ != -1 &&
        transient_entry_index_ == GetEntryCount() - 1) ||
       (pending_entry_ && (pending_entry_index_ == -1 ||
                           pending_entry_index_ == GetEntryCount() - 1)) ||
       (!pending_entry_ && last_committed_entry_index_ == GetEntryCount() - 1));
 
   // Remove all the entries leaving the active entry.
@@ skipping 20 matching lines @@
   if (pending_entry_index_ != -1)
     pending_entry_index_ = GetEntryCount() - 1;
   if (transient_entry_index_ != -1) {
     // There's a transient entry. In this case we want the last committed to
     // point to the previous entry.
     transient_entry_index_ = GetEntryCount() - 1;
     if (last_committed_entry_index_ != -1)
       last_committed_entry_index_--;
   }
 
-  tab_contents_->SetHistoryLengthAndPrune(site_instance.get(),
+  web_contents_->SetHistoryLengthAndPrune(site_instance.get(),
                                           max_source_index,
                                           minimum_page_id);
 
   // Copy the max page id map from the old tab to the new tab.  This ensures
   // that new and existing navigations in the tab's current SiteInstances
   // are identified properly.
-  tab_contents_->CopyMaxPageIDsFrom(source->tab_contents());
+  web_contents_->CopyMaxPageIDsFrom(source->web_contents());
 
   // If there is a last committed entry, be sure to include it in the new
   // max page ID map.
   if (max_page_id > -1) {
-    tab_contents_->UpdateMaxPageIDForSiteInstance(site_instance.get(),
+    web_contents_->UpdateMaxPageIDForSiteInstance(site_instance.get(),
                                                   max_page_id);
   }
 }
 
 void NavigationControllerImpl::PruneAllButActive() {
   if (transient_entry_index_ != -1) {
     // There is a transient entry. Prune up to it.
     DCHECK_EQ(GetEntryCount() - 1, transient_entry_index_);
     entries_.erase(entries_.begin(), entries_.begin() + transient_entry_index_);
     transient_entry_index_ = 0;
@@ skipping 14 matching lines @@
     entries_.erase(entries_.begin() + 1, entries_.end());
     pending_entry_index_ = 0;
     last_committed_entry_index_ = 0;
   } else {
     // There is a pending_entry, but it's not in entries_.
     pending_entry_index_ = -1;
     last_committed_entry_index_ = -1;
     entries_.clear();
   }
 
-  if (tab_contents_->GetInterstitialPage()) {
+  if (web_contents_->GetInterstitialPage()) {
     // Normally the interstitial page hides itself if the user doesn't proceeed.
     // This would result in showing a NavigationEntry we just removed. Set this
     // so the interstitial triggers a reload if the user doesn't proceed.
-    static_cast<InterstitialPageImpl*>(tab_contents_->GetInterstitialPage())->
+    static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
         set_reload_on_dont_proceed(true);
   }
 }
 
 void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
   max_restored_page_id_ = max_id;
 }
 
 int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
   return max_restored_page_id_;
@@ skipping 19 matching lines @@
     last_committed_entry_index_--;
 }
 
 void NavigationControllerImpl::DiscardNonCommittedEntries() {
   bool transient = transient_entry_index_ != -1;
   DiscardNonCommittedEntriesInternal();
 
   // If there was a transient entry, invalidate everything so the new active
   // entry state is shown.
   if (transient) {
-    tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
+    web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
   }
 }
 
 NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
   return pending_entry_;
 }
 
 int NavigationControllerImpl::GetPendingEntryIndex() const {
   return pending_entry_index_;
 }
@@ skipping 32 matching lines @@
     if (num_pruned > 0)  // Only notify if we did prune something.
       NotifyPrunedEntries(this, false, num_pruned);
   }
 
   PruneOldestEntryIfFull();
 
   entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
   last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1;
 
   // This is a new page ID, so we need everybody to know about it.
-  tab_contents_->UpdateMaxPageID(entry->GetPageID());
+  web_contents_->UpdateMaxPageID(entry->GetPageID());
 }
 
 void NavigationControllerImpl::PruneOldestEntryIfFull() {
   if (entries_.size() >= max_entry_count()) {
     DCHECK_EQ(max_entry_count(), entries_.size());
     DCHECK(last_committed_entry_index_ > 0);
     RemoveEntryAtIndex(0);
     NotifyPrunedEntries(this, true, 1);
   }
 }
 
 void NavigationControllerImpl::NavigateToPendingEntry(ReloadType reload_type) {
   needs_reload_ = false;
 
   // If we were navigating to a slow-to-commit page, and the user performs
   // a session history navigation to the last committed page, RenderViewHost
   // will force the throbber to start, but WebKit will essentially ignore the
   // navigation, and won't send a message to stop the throbber. To prevent this
   // from happening, we drop the navigation here and stop the slow-to-commit
   // page from loading (which would normally happen during the navigation).
   if (pending_entry_index_ != -1 &&
       pending_entry_index_ == last_committed_entry_index_ &&
       (entries_[pending_entry_index_]->restore_type() ==
           NavigationEntryImpl::RESTORE_NONE) &&
       (entries_[pending_entry_index_]->GetTransitionType() &
           content::PAGE_TRANSITION_FORWARD_BACK)) {
-    tab_contents_->Stop();
+    web_contents_->Stop();
 
     // If an interstitial page is showing, we want to close it to get back
     // to what was showing before.
-    if (tab_contents_->GetInterstitialPage())
-      tab_contents_->GetInterstitialPage()->DontProceed();
+    if (web_contents_->GetInterstitialPage())
+      web_contents_->GetInterstitialPage()->DontProceed();
 
     DiscardNonCommittedEntries();
     return;
   }
 
   // If an interstitial page is showing, the previous renderer is blocked and
   // cannot make new requests.  Unblock (and disable) it to allow this
   // navigation to succeed.  The interstitial will stay visible until the
   // resulting DidNavigate.
-  if (tab_contents_->GetInterstitialPage()) {
-    static_cast<InterstitialPageImpl*>(tab_contents_->GetInterstitialPage())->
+  if (web_contents_->GetInterstitialPage()) {
+    static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
         CancelForNavigation();
   }
 
   // For session history navigations only the pending_entry_index_ is set.
   if (!pending_entry_) {
     DCHECK_NE(pending_entry_index_, -1);
     pending_entry_ = entries_[pending_entry_index_].get();
   }
 
-  if (!tab_contents_->NavigateToPendingEntry(reload_type))
+  if (!web_contents_->NavigateToPendingEntry(reload_type))
     DiscardNonCommittedEntries();
 
   // If the entry is being restored and doesn't have a SiteInstance yet, fill
   // it in now that we know. This allows us to find the entry when it commits.
   // This works for browser-initiated navigations. We handle renderer-initiated
-  // navigations to restored entries in TabContents::OnGoToEntryAtOffset.
+  // navigations to restored entries in WebContentsImpl::OnGoToEntryAtOffset.
   if (pending_entry_ && !pending_entry_->site_instance() &&
       pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
     pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
-        tab_contents_->GetPendingSiteInstance()));
+        web_contents_->GetPendingSiteInstance()));
     pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
   }
 }
 
 void NavigationControllerImpl::NotifyNavigationEntryCommitted(
     content::LoadCommittedDetails* details) {
   details->entry = GetActiveEntry();
   content::NotificationDetails notification_details =
       content::Details<content::LoadCommittedDetails>(details);
 
-  // We need to notify the ssl_manager_ before the tab_contents_ so the
+  // We need to notify the ssl_manager_ before the web_contents_ so the
   // location bar will have up-to-date information about the security style
   // when it wants to draw.  See http://crbug.com/11157
   ssl_manager_.DidCommitProvisionalLoad(notification_details);
 
   // TODO(pkasting): http://b/1113079 Probably these explicit notification paths
   // should be removed, and interested parties should just listen for the
   // notification below instead.
-  tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
+  web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(this),
       notification_details);
 }
 
 // static
 size_t NavigationControllerImpl::max_entry_count() {
   if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet)
@@ skipping 80 matching lines @@
   for (int i = 0; i < max_index; i++) {
     // When cloning a tab, copy all entries except interstitial pages
     if (source.entries_[i].get()->GetPageType() !=
         content::PAGE_TYPE_INTERSTITIAL) {
       entries_.insert(entries_.begin() + insert_index++,
                       linked_ptr<NavigationEntryImpl>(
                           new NavigationEntryImpl(*source.entries_[i])));
     }
   }
 }