Revert 18512 - Revert 18373 Consider a redirect following user gesture as us...

chrome/browser/tab_contents/navigation_controller.cc

 // Copyright (c) 2006-2008 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/tab_contents/navigation_controller.h"
 
 #include "app/resource_bundle.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 72 matching lines @@
 bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) {
   if (existing_url == new_url || !new_url.has_ref())
     return false;
 
   url_canon::Replacements<char> replacements;
   replacements.ClearRef();
   return existing_url.ReplaceComponents(replacements) ==
       new_url.ReplaceComponents(replacements);
 }
 
+// Navigation within this limit since the last document load is considered to
+// be automatic (i.e., machine-initiated) rather than user-initiated unless
+// a user gesture has been observed.
+const base::TimeDelta kMaxAutoNavigationTimeDelta =
+    base::TimeDelta::FromSeconds(5);
+
 }  // namespace
 
 // NavigationController ---------------------------------------------------
 
 // static
 size_t NavigationController::max_entry_count_ = 50;
 
 // static
 bool NavigationController::check_for_repost_ = true;
 
@@ skipping 314 matching lines @@
 
 const SkBitmap& NavigationController::GetLazyFavIcon() const {
   if (pending_entry_) {
     return pending_entry_->favicon().bitmap();
   } else {
     ResourceBundle &rb = ResourceBundle::GetSharedInstance();
     return *rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
   }
 }
 
+void NavigationController::DocumentLoadedInFrame() {
+  last_document_loaded_ = base::TimeTicks::Now();
+}
+
+void NavigationController::OnUserGesture() {
+  user_gesture_observed_ = true;
+}
+
 bool NavigationController::RendererDidNavigate(
     const ViewHostMsg_FrameNavigate_Params& params,
     LoadCommittedDetails* details) {
   // Save the previous state before we clobber it.
   if (GetLastCommittedEntry()) {
     details->previous_url = GetLastCommittedEntry()->url();
     details->previous_entry_index = last_committed_entry_index();
   } else {
     details->previous_url = GURL();
     details->previous_entry_index = -1;
@@ skipping 61 matching lines @@
 
   // Now prep the rest of the details for the notification and broadcast.
   details->entry = GetActiveEntry();
   details->is_in_page = IsURLInPageNavigation(params.url);
   details->is_main_frame = PageTransition::IsMainFrame(params.transition);
   details->serialized_security_info = params.security_info;
   details->is_content_filtered = params.is_content_filtered;
   details->http_status_code = params.http_status_code;
   NotifyNavigationEntryCommitted(details);
 
+  user_gesture_observed_ = false;
+
   return true;
 }
 
 NavigationType::Type NavigationController::ClassifyNavigation(
     const ViewHostMsg_FrameNavigate_Params& params) const {
   // If a page makes a popup navigated to about blank, and then writes stuff
   // like a subframe navigated to a real site, we'll get a notification with an
   // invalid page ID. There's nothing we can do with these, so just ignore them.
   if (params.page_id == -1) {
     DCHECK(!GetActiveEntry()) << "Got an invalid page ID but we seem to be "
@@ skipping 60 matching lines @@
   // navigations that don't actually navigate, but it can happen when there is
   // an encoding override (it always sends a navigation request).
   if (AreURLsInPageNavigation(existing_entry->url(), params.url))
     return NavigationType::IN_PAGE;
 
   // Since we weeded out "new" navigations above, we know this is an existing
   // (back/forward) navigation.
   return NavigationType::EXISTING_PAGE;
 }
 
+bool NavigationController::IsRedirect(
+  const ViewHostMsg_FrameNavigate_Params& params) {
+  // 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;
+}
+
+bool NavigationController::IsLikelyAutoNavigation(base::TimeTicks now) {
+  return !user_gesture_observed_ &&
+         (now - last_document_loaded_) < kMaxAutoNavigationTimeDelta;
+}
+
 void NavigationController::RendererDidNavigateToNewPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   NavigationEntry* new_entry;
   if (pending_entry_) {
     // 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. This goes along
     // with a similar TODO at the top of RendererDidNavigate where we blindly
     // set the site instance on the pending entry.
     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(NavigationEntry::NORMAL_PAGE);
   } else {
     new_entry = new NavigationEntry;
   }
 
   new_entry->set_url(params.url);
   new_entry->set_referrer(params.referrer);
   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);
 
-  // If the current entry is a redirection source, it needs to be replaced with
-  // the new entry to avoid unwanted redirections in navigating backward /
-  // forward. Otherwise, just insert the new entry.
+  // If the current entry is a redirection source and the redirection has
+  // occurred within kMaxAutoNavigationTimeDelta since the last document load,
+  // this is likely to be machine-initiated redirect and the entry needs to be
+  // replaced with the new entry to avoid unwanted redirections in navigating
+  // backward/forward.
+  // Otherwise, just insert the new entry.
   InsertOrReplaceEntry(new_entry,
-      PageTransition::IsRedirect(new_entry->transition_type()));
+      IsRedirect(params) && IsLikelyAutoNavigation(base::TimeTicks::Now()));
 }
 
 void NavigationController::RendererDidNavigateToExistingPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // 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.
@@ skipping 51 matching lines @@
   NavigationEntry* existing_entry = GetEntryWithPageID(
       tab_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).
   NavigationEntry* new_entry = new NavigationEntry(*existing_entry);
   new_entry->set_page_id(params.page_id);
   new_entry->set_url(params.url);
-  InsertOrReplaceEntry(new_entry, false);
+  InsertOrReplaceEntry(new_entry,
+      IsRedirect(params) && IsLikelyAutoNavigation(base::TimeTicks::Now()));
 }
 
 void NavigationController::RendererDidNavigateNewSubframe(
     const ViewHostMsg_FrameNavigate_Params& params) {
+  if (PageTransition::StripQualifier(params.transition) ==
+      PageTransition::AUTO_SUBFRAME) {
+    // This is not user-initiated. Ignore.
+    return;
+  }
+  if (IsRedirect(params)) {
+    // This is redirect. Ignore.
+    return;
+  }
+
   // Manual subframe navigations just get the current entry cloned so the user
   // can go back or forward to it. The actual subframe information will be
   // stored in the page state for each of those entries. This happens out of
   // band with the actual navigations.
   DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
                                   << "that a last committed entry exists.";
   NavigationEntry* new_entry = new NavigationEntry(*GetLastCommittedEntry());
   new_entry->set_page_id(params.page_id);
   InsertOrReplaceEntry(new_entry, false);
 }
@@ skipping 269 matching lines @@
       return i;
   }
   return -1;
 }
 
 NavigationEntry* NavigationController::GetTransientEntry() const {
   if (transient_entry_index_ == -1)
     return NULL;
   return entries_[transient_entry_index_].get();
 }