Commit instant loader when the instant page navigates away from instant URL.

chrome/browser/instant/instant_controller.cc

 // Copyright 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/instant/instant_controller.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 420 matching lines @@
   // If we are on an already committed search results page, send a submit event
   // to the page, but otherwise, nothing else to do.
   if (instant_tab_) {
     if (last_match_was_search_ && type == INSTANT_COMMIT_PRESSED_ENTER) {
       instant_tab_->Submit(last_omnibox_text_);
       return true;
     }
     return false;
   }
 
-  if (!IsCurrent())
+  if (!IsCurrent() && type != INSTANT_COMMIT_NAVIGATED)
     return false;
 
   if (type == INSTANT_COMMIT_FOCUS_LOST)
     loader_->Cancel(last_omnibox_text_);
-  else
+  else if (type != INSTANT_COMMIT_NAVIGATED)
     loader_->Submit(last_omnibox_text_);
 
   content::WebContents* preview = loader_->ReleaseContents();
 
   if (extended_enabled_) {
     // Consider what's happening:
     //   1. The user has typed a query in the omnibox and committed it (either
     //      by pressing Enter or clicking on the preview).
     //   2. We commit the preview to the tab strip, and tell the page.
     //   3. The page will update the URL hash fragment with the query terms.
@@ skipping 17 matching lines @@
     }
   }
 
   // If the preview page has navigated since the last Update(), we need to add
   // the navigation to history ourselves. Else, the page will navigate after
   // commit, and it will be added to history in the usual manner.
   const history::HistoryAddPageArgs& last_navigation =
       loader_->last_navigation();
   if (!last_navigation.url.is_empty()) {
     content::NavigationEntry* entry = preview->GetController().GetActiveEntry();
-    DCHECK_EQ(last_navigation.url, entry->GetURL());
+
+    // The last navigation should be the same as the active entry if the loader
+    // is in search mode. During navigation, the active entry could have
+    // changed since DidCommitProvisionalLoadForFrame is called after the entry
+    // is changed.
+    // TODO(shishir): Should we commit the last navigation for
+    // INSTANT_COMMIT_NAVIGATED.
+    DCHECK(type == INSTANT_COMMIT_NAVIGATED ||
+           last_navigation.url == entry->GetURL());
 
     // Add the page to history.
     HistoryTabHelper* history_tab_helper =
         HistoryTabHelper::FromWebContents(preview);
     history_tab_helper->UpdateHistoryForNavigation(last_navigation);
 
     // Update the page title.
     history_tab_helper->UpdateHistoryPageTitle(*entry);
   }
 
@@ skipping 264 matching lines @@
 
 void InstantController::InstantLoaderContentsFocused() {
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
   if (!model_.mode().is_default())
     browser_->InstantPreviewFocused();
 #endif
 }
 
+void InstantController::InstantClientAboutToNavigate(const GURL& url) {
+  GURL instant_url(loader_->instant_url());
+
+  // Might be navigating to the instant URL.
+  if (url == instant_url)
+    return;
+
+  // Don't commit if the URL being navigated to has the same host and path as
+  // the instant URL. This enables the instant page to change the query
+  // parameters and fragments of the URL without it navigating.
+  if (url.host() != instant_url.host() || url.path() != instant_url.path())
+    CommitIfCurrent(INSTANT_COMMIT_NAVIGATED);
+}
+
 bool InstantController::ResetLoader(const TemplateURL* template_url,
                                     const content::WebContents* active_tab) {
   std::string instant_url;
   if (!GetInstantURL(template_url, &instant_url))
     return false;
 
   if (loader_ && loader_->instant_url() == instant_url)
     return true;
 
   HideInternal();
@@ skipping 226 matching lines @@
   }
 
   std::map<std::string, int>::const_iterator iter =
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
       iter->second > kMaxInstantSupportFailures)
     return false;
 
   return true;
 }