Cancel prerender when a site tries to register a protocol handler.

chrome/browser/prerender/prerender_contents.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 "chrome/browser/prerender/prerender_contents.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/process_util.h"
@@ skipping 105 matching lines @@
 
 // TabContentsDelegateImpl -----------------------------------------------------
 
 class PrerenderContents::TabContentsDelegateImpl
     : public content::WebContentsDelegate {
  public:
   explicit TabContentsDelegateImpl(PrerenderContents* prerender_contents) :
       prerender_contents_(prerender_contents) {
   }
 
- virtual WebContents* OpenURLFromTab(WebContents* source,
+  // content::WebContentsDelegate implementation:
+  virtual WebContents* OpenURLFromTab(WebContents* source,
                                      const OpenURLParams& params) OVERRIDE {
     // |OpenURLFromTab| is typically called when a frame performs a navigation
     // that requires the browser to perform the transition instead of WebKit.
     // Examples include prerendering a site that redirects to an app URL,
     // or if --enable-strict-site-isolation is specified and the prerendered
     // frame redirects to a different origin.
-    // TODO(cbentzel): Consider supporting this is if it is a common case
-    // during prerenders.
+    // TODO(cbentzel): Consider supporting this if it is a common case during
+    // prerenders.
     prerender_contents_->Destroy(FINAL_STATUS_OPEN_URL);
     return NULL;
   }
 
-  // content::WebContentsDelegate implementation:
   virtual bool ShouldAddNavigationToHistory(
       const history::HistoryAddPageArgs& add_page_args,
       content::NavigationType navigation_type) OVERRIDE {
     add_page_vector_.push_back(
         scoped_refptr<history::HistoryAddPageArgs>(add_page_args.Clone()));
     return false;
   }
 
   virtual bool CanDownload(RenderViewHost* render_view_host,
                            int request_id,
@@ skipping 24 matching lines @@
 
   virtual bool OnGoToEntryOffset(int offset) OVERRIDE {
     // This isn't allowed because the history merge operation
     // does not work if there are renderer issued challenges.
     // TODO(cbentzel): Cancel in this case? May not need to do
     // since render-issued offset navigations are not guaranteed,
     // but indicates that the page cares about the history.
     return false;
   }
 
   virtual void JSOutOfMemory(WebContents* tab) OVERRIDE {

[mmenke, 2012/06/25 19:53:39]

We should be consistent about whether we call destroy here, or call a
prerender_contents_ function that does so.  I prefer the former, myself, to keep
stuff out of the header and avoid extra 1-line functions.  If you disagree, can
just go the other way.

[dominich, 2012/06/25 19:59:27]

I like this better.

-    prerender_contents_->OnJSOutOfMemory();
+    prerender_contents_->Destroy(FINAL_STATUS_JS_OUT_OF_MEMORY);
   }
 
   virtual bool ShouldSuppressDialogs() OVERRIDE {
-    return prerender_contents_->ShouldSuppressDialogs();
+    // Always suppress JavaScript messages if they're triggered by a page being
+    // prerendered.
+    // We still want to show the user the message when they navigate to this
+    // page, so cancel this prerender.
+    prerender_contents_->Destroy(FINAL_STATUS_JAVASCRIPT_ALERT);
+    return true;
+  }
+
+  virtual void RegisterProtocolHandler(WebContents* web_contents,
+                                       const std::string& protocol,
+                                       const GURL& url,
+                                       const string16& title,
+                                       bool user_gesture) OVERRIDE {
+    // TODO(mmenke): Consider supporting this if it is a common case during
+    // prerenders.
+    prerender_contents_->Destroy(FINAL_STATUS_REGISTER_PROTOCOL_HANDLER);
   }
 
   // Commits the History of Pages to the given TabContents.
   void CommitHistory(TabContents* tab) {
     for (size_t i = 0; i < add_page_vector_.size(); ++i)
       tab->history_tab_helper()->UpdateHistoryForNavigation(
           add_page_vector_[i].get());
   }
 
  private:
@@ skipping 360 matching lines @@
                    alias_urls_.end(),
                    PrerenderURLPredicate(url));
   if (matching_url_iterator != alias_urls_.end()) {
     if (matching_url)
       *matching_url = *matching_url_iterator;
     return true;
   }
   return false;
 }
 
-void PrerenderContents::OnJSOutOfMemory() {
-  Destroy(FINAL_STATUS_JS_OUT_OF_MEMORY);
-}
-
 void PrerenderContents::RenderViewGone(base::TerminationStatus status) {
   Destroy(FINAL_STATUS_RENDERER_CRASHED);
 }
 
 void PrerenderContents::DidStopLoading() {
   has_stopped_loading_ = true;
 }
 
 void PrerenderContents::DidStartProvisionalLoadForFrame(
     int64 frame_id,
@@ skipping 15 matching lines @@
   }
 }
 
 void PrerenderContents::DidFinishLoad(int64 frame_id,
                                       const GURL& validated_url,
                                       bool is_main_frame) {
   if (is_main_frame)
     has_finished_loading_ = true;
 }
 
-bool PrerenderContents::ShouldSuppressDialogs() {
-  // Always suppress JavaScript messages if they're triggered by a page being
-  // prerendered.
-  // We still want to show the user the message when they navigate to this
-  // page, so cancel this prerender.
-  Destroy(FINAL_STATUS_JAVASCRIPT_ALERT);
-  return true;
-}
-
 void PrerenderContents::Destroy(FinalStatus final_status) {
   if (prerendering_has_been_cancelled_)
     return;
 
   if (child_id_ != -1 && route_id_ != -1) {
     // Cancel the prerender in the PrerenderTracker.  This is needed
     // because destroy may be called directly from the UI thread without calling
     // TryCancel().  This is difficult to completely avoid, since prerendering
     // can be cancelled before a RenderView is created.
     bool is_cancelled = prerender_tracker_->TryCancel(
@@ skipping 95 matching lines @@
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_.get() || !prerender_contents_->web_contents())
     return false;
   const WebContents* web_contents = prerender_contents_->web_contents();
   return (web_contents->GetSiteInstance() !=
           web_contents->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender