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

chrome/browser/instant/instant_loader.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_loader.h"
 
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
+#include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 #include "chrome/browser/history/history_tab_helper.h"
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/safe_browsing/safe_browsing_tab_observer.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/constrained_window_tab_helper_delegate.h"
 #include "chrome/browser/ui/search/search_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 46 matching lines @@
   virtual void WebContentsFocused(content::WebContents* contents) OVERRIDE;
   virtual bool CanDownload(content::RenderViewHost* render_view_host,
                            int request_id,
                            const std::string& request_method) OVERRIDE;
   virtual void HandleMouseDown() OVERRIDE;
   virtual void HandleMouseUp() OVERRIDE;
   virtual void HandlePointerActivate() OVERRIDE;
   virtual void HandleGestureEnd() OVERRIDE;
   virtual void DragEnded() OVERRIDE;
   virtual bool OnGoToEntryOffset(int offset) OVERRIDE;
+  virtual content::WebContents* OpenURLFromTab(
+      content::WebContents* source,
+      const content::OpenURLParams& params) OVERRIDE;
 
   void MaybeCommitFromPointerRelease();
 
   InstantLoader* const loader_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDelegateImpl);
 };
 
 InstantLoader::WebContentsDelegateImpl::WebContentsDelegateImpl(
     InstantLoader* loader)
@@ skipping 65 matching lines @@
   // If the user drags, we won't get a mouse up (at least on Linux). Commit the
   // Instant result when the drag ends, so that during the drag the page won't
   // move around.
   MaybeCommitFromPointerRelease();
 }
 
 bool InstantLoader::WebContentsDelegateImpl::OnGoToEntryOffset(int offset) {
   return false;
 }
 
+content::WebContents* InstantLoader::WebContentsDelegateImpl::OpenURLFromTab(
+    content::WebContents* source,
+    const content::OpenURLParams& params) {
+  content::WebContents* preview = loader_->contents_.get();
+  if (loader_->controller_->CommitIfPossible(INSTANT_COMMIT_NAVIGATED))
+    return preview->GetDelegate()->OpenURLFromTab(source, params);
+  return NULL;
+}
+
 void InstantLoader::WebContentsDelegateImpl::MaybeCommitFromPointerRelease() {
   if (loader_->is_pointer_down_from_activate_) {
     loader_->is_pointer_down_from_activate_ = false;
     loader_->controller_->CommitIfPossible(INSTANT_COMMIT_FOCUS_LOST);
   }
 }
 
 // InstantLoader ---------------------------------------------------------------
 
 // static
@@ skipping 121 matching lines @@
 void InstantLoader::StopCapturingKeyStrokes() {
   InstantSupportDetermined(true);
   // NOTE(samarth): the current implementation of the key capturing (invisible
   // focus) doesn't require doing anything explicitly here.
 }
 
 void InstantLoader::RenderViewGone() {
   controller_->InstantLoaderRenderViewGone();
 }
 
+void InstantLoader::AboutToNavigateMainFrame(const GURL& url) {
+  controller_->InstantLoaderAboutToNavigateMainFrame(url);
+}
+
 void InstantLoader::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
 #if defined(OS_MACOSX)
   if (type == content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED) {
     if (content::RenderWidgetHostView* rwhv =
             contents_->GetRenderWidgetHostView())
       rwhv->SetTakesFocusOnlyOnMouseDown(true);
     return;
   }
@@ skipping 23 matching lines @@
       set_delegate(delegate_.get());
 
   // A tab helper to catch prerender content swapping shenanigans.
   CoreTabHelper::CreateForWebContents(contents());
   CoreTabHelper::FromWebContents(contents())->set_delegate(delegate_.get());
 
   // Tab helpers used when committing a preview.
   chrome::search::SearchTabHelper::CreateForWebContents(contents());
   HistoryTabHelper::CreateForWebContents(contents());
 
+  // Observers.
+  extensions::WebNavigationTabObserver::CreateForWebContents(contents());
+
   // And some flat-out paranoia.
   safe_browsing::SafeBrowsingTabObserver::CreateForWebContents(contents());
 
 #if defined(OS_MACOSX)
   // If |contents_| doesn't yet have a RWHV, SetTakesFocusOnlyOnMouseDown() will
   // be called later, when NOTIFICATION_RENDER_VIEW_HOST_CHANGED is received.
   if (content::RenderWidgetHostView* rwhv =
           contents_->GetRenderWidgetHostView())
     rwhv->SetTakesFocusOnlyOnMouseDown(true);
   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
@@ skipping 33 matching lines @@
                                            content::WebContents* new_contents) {
   DCHECK_EQ(old_contents, contents());
   CleanupPreviewContents();
   // We release here without deleting so that the caller still has the
   // responsibility for deleting the WebContents.
   ignore_result(contents_.release());
   contents_.reset(new_contents);
   SetupPreviewContents();
   controller_->SwappedWebContents();
 }