Fix regression with back-button not working on prerendered and instant pages.

content/browser/tab_contents/navigation_controller.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 "content/browser/tab_contents/navigation_controller.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 324 matching lines @@
   // If an interstitial page is showing, going back is equivalent to hiding the
   // interstitial.
   if (tab_contents_->interstitial_page()) {
     tab_contents_->interstitial_page()->DontProceed();
     return;
   }
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
+  LOG(ERROR) << "GoBack";
+  for (int i = 0; i < current_index; ++i) {
+    LOG(ERROR) << entries_[i]->url().spec();
+  }
+
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index - 1;
   entries_[pending_entry_index_]->set_transition_type(
       entries_[pending_entry_index_]->transition_type() |
       PageTransition::FORWARD_BACK);
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoForward() {
@@ skipping 254 matching lines @@
   }
 
   // Now we know that the notification is for an existing page. Find that entry.
   int existing_entry_index = GetEntryIndexWithPageID(
       tab_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();
+    //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;
     UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
     if (tab_contents_->GetSiteInstance()->HasProcess())
       tab_contents_->GetSiteInstance()->GetProcess()->ReceivedBadMessage();
     return NavigationType::NAV_IGNORE;
   }
   NavigationEntry* existing_entry = entries_[existing_entry_index].get();
@@ skipping 39 matching lines @@
   // For main frame transition, we judge by params.transition.
   // Otherwise, by params.redirects.
   if (PageTransition::IsMainFrame(params.transition)) {
     return PageTransition::IsRedirect(params.transition);
   }
   return params.redirects.size() > 1;
 }
 
 void NavigationController::RendererDidNavigateToNewPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
+  LOG(ERROR) << "RendererDidNavigateToNewPage."
+             << " url=" << params.url;
   NavigationEntry* new_entry;
   bool update_virtual_url;
   if (pending_entry_) {
+    LOG(ERROR) << "Pending Entry exists";
     // TODO(brettw) this assumes that the pending entry is appropriate for the
     // new page that was just loaded. I don't think this is necessarily the
     // case! We should have some more tracking to know for sure.
     new_entry = new NavigationEntry(*pending_entry_);
 
     // Don't use the page type from the pending entry. Some interstitial page
     // may have set the type to interstitial. Once we commit, however, the page
     // type must always be normal.
     new_entry->set_page_type(NORMAL_PAGE);
     update_virtual_url = new_entry->update_virtual_url_with_url();
@@ skipping 13 matching lines @@
   new_entry->set_page_id(params.page_id);
   new_entry->set_transition_type(params.transition);
   new_entry->set_site_instance(tab_contents_->GetSiteInstance());
   new_entry->set_has_post_data(params.is_post);
 
   InsertOrReplaceEntry(new_entry, *did_replace_entry);
 }
 
 void NavigationController::RendererDidNavigateToExistingPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
+  LOG(ERROR) << "RendererDidNavigateToExistingPage."
+             << " url=" << params.url;
   // We should only get here for main frame navigations.
   DCHECK(PageTransition::IsMainFrame(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(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
@@ skipping 199 matching lines @@
   last_committed_entry_index_ = entry_count() - 1;
   if (pending_entry_index_ != -1)
     pending_entry_index_ = entry_count() - 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_ = entry_count() - 1;
     if (last_committed_entry_index_ != -1)
       last_committed_entry_index_--;
   }
+
+  LOG(ERROR) << "OffsetAndPrune."
+             << " last_committed_entry_index_=" << last_committed_entry_index_;
+  // Send a message to active render view asking to offset messages.
+  tab_contents_->OffsetAndPruneHistory(entry_count() - 1);
 }
 
 void NavigationController::PruneAllButActive() {
   if (transient_entry_index_ != -1) {
     // There is a transient entry. Prune up to it.
     DCHECK_EQ(entry_count() - 1, transient_entry_index_);
     entries_.erase(entries_.begin(), entries_.begin() + transient_entry_index_);
     transient_entry_index_ = 0;
     last_committed_entry_index_ = -1;
     pending_entry_index_ = -1;
@@ skipping 224 matching lines @@
   size_t insert_index = 0;
   for (int i = 0; i < max_index; i++) {
     // When cloning a tab, copy all entries except interstitial pages
     if (source.entries_[i].get()->page_type() != INTERSTITIAL_PAGE) {
       entries_.insert(entries_.begin() + insert_index++,
                       linked_ptr<NavigationEntry>(
                           new NavigationEntry(*source.entries_[i])));
     }
   }
 }