[PlzNavigate] Use WebContentsGetter in PrerenderResourceThrottle

chrome/browser/prerender/prerender_resource_throttle.cc

 // Copyright 2013 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_resource_throttle.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
+using content::ResourceRequestInfo;
 using content::ResourceType;
 
 namespace prerender {
 
 namespace {
 static const char kFollowOnlyWhenPrerenderShown[] =
     "follow-only-when-prerender-shown";
 
 PrerenderContents* g_prerender_contents_for_testing;
 
 // Returns true if the response has a "no-store" cache control header.
 bool IsNoStoreResponse(const net::URLRequest& request) {
   const net::HttpResponseInfo& response_info = request.response_info();
   return response_info.headers.get() &&
          response_info.headers->HasHeaderValue("cache-control", "no-store");
 }
 
 }  // namespace
 
 // Used to pass information between different UI thread tasks of the same
 // throttle. This is reference counted as the throttler may be destroyed before
 // the UI thread task has a chance to run.
 //
 // This class is created on the IO thread, and destroyed on the UI thread. Its
 // members should only be accessed on the UI thread.
 class PrerenderThrottleInfo
     : public base::RefCountedThreadSafe<PrerenderThrottleInfo,
                                         BrowserThread::DeleteOnUIThread> {
  public:
-  PrerenderThrottleInfo() : manager_(nullptr) {}
+  PrerenderThrottleInfo()
+      : mode_(NO_PRERENDER), origin_(ORIGIN_NONE), manager_(nullptr) {}
 
   void Set(PrerenderMode mode, Origin origin, PrerenderManager* manager) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     mode_ = mode;
     origin_ = origin;
     manager_ = manager->AsWeakPtr();
   }
 
   PrerenderMode mode() const { return mode_; }
   Origin origin() const { return origin_; }
@@ skipping 24 matching lines @@
 
 PrerenderResourceThrottle::~PrerenderResourceThrottle() {}
 
 void PrerenderResourceThrottle::WillStartRequest(bool* defer) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillStartRequestOnUI, AsWeakPtr(),
-                 request_->method(), info->GetResourceType(),
-                 info->GetChildID(), info->GetRenderFrameID(), request_->url(),
+                 request_->method(), info->GetResourceType(), request_->url(),
+                 info->GetWebContentsGetterForRequest(),
                  prerender_throttle_info_));
 }
 
 void PrerenderResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
   std::string header;
   request_->GetResponseHeaderByName(kFollowOnlyWhenPrerenderShown, &header);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillRedirectRequestOnUI,
                  AsWeakPtr(), header, info->GetResourceType(), info->IsAsync(),
-                 IsNoStoreResponse(*request_), info->GetChildID(),
-                 info->GetRenderFrameID(), redirect_info.new_url));
+                 IsNoStoreResponse(*request_), redirect_info.new_url,
+                 info->GetWebContentsGetterForRequest()));
 }
 
 void PrerenderResourceThrottle::WillProcessResponse(bool* defer) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   if (!info)
     return;
 
   DCHECK_GT(request_->url_chain().size(), 0u);
   int redirect_count =
       base::saturated_cast<int>(request_->url_chain().size()) - 1;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillProcessResponseOnUI,
                  content::IsResourceTypeFrame(info->GetResourceType()),
                  IsNoStoreResponse(*request_), redirect_count,
-                 info->GetChildID(), info->GetRenderFrameID(),
                  prerender_throttle_info_));
 }
 
 const char* PrerenderResourceThrottle::GetNameForLogging() const {
   return "PrerenderResourceThrottle";
 }
 
 void PrerenderResourceThrottle::ResumeHandler() {
   Resume();
 }
 
 // static
 void PrerenderResourceThrottle::WillStartRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& method,
     ResourceType resource_type,
-    int render_process_id,
-    int render_frame_id,
     const GURL& url,
+    const ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     scoped_refptr<PrerenderThrottleInfo> prerender_throttle_info) {
   bool cancel = false;
   PrerenderContents* prerender_contents =
-      PrerenderContentsFromRenderFrame(render_process_id, render_frame_id);
+      PrerenderContentsFromGetter(web_contents_getter);
   if (prerender_contents) {
     DCHECK(prerender_throttle_info);
     prerender_throttle_info->Set(prerender_contents->prerender_mode(),
                                  prerender_contents->origin(),
                                  prerender_contents->prerender_manager());
 
     // Abort any prerenders that spawn requests that use unsupported HTTP
     // methods or schemes.
     if (!prerender_contents->IsValidHttpMethod(method)) {
       // If this is a full prerender, cancel the prerender in response to
       // invalid requests.  For prefetches, cancel invalid requests but keep the
       // prefetch going, unless it's the main frame that's invalid.
       if (prerender_contents->prerender_mode() == FULL_PRERENDER ||
           resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
         prerender_contents->Destroy(FINAL_STATUS_INVALID_HTTP_METHOD);
       }
       cancel = true;
-    } else if (!PrerenderManager::DoesSubresourceURLHaveValidScheme(url)) {
+    } else if (!PrerenderManager::DoesSubresourceURLHaveValidScheme(url) &&
+               resource_type != content::RESOURCE_TYPE_MAIN_FRAME) {
+      // Destroying the prerender for unsupported scheme only for non-main
+      // resource to allow chrome://crash to actually crash in the
+      // *RendererCrash tests instead of being intercepted here. The unsupported
+      // scheme for the main resource is checked in WillRedirectRequestOnUI()
+      // and PrerenderContents::CheckURL(). See http://crbug.com/673771.
       prerender_contents->Destroy(FINAL_STATUS_UNSUPPORTED_SCHEME);
       ReportUnsupportedPrerenderScheme(url);
       cancel = true;
 #if defined(OS_ANDROID)
     } else if (resource_type == content::RESOURCE_TYPE_FAVICON) {
       // Delay icon fetching until the contents are getting swapped in
       // to conserve network usage in mobile devices.
       prerender_contents->AddResourceThrottle(throttle);
       return;
 #endif
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(cancel ? &PrerenderResourceThrottle::Cancel
                         : &PrerenderResourceThrottle::ResumeHandler,
                  throttle));
 }
 
 // static
 void PrerenderResourceThrottle::WillRedirectRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& follow_only_when_prerender_shown_header,
     ResourceType resource_type,
     bool async,
     bool is_no_store,
-    int render_process_id,
-    int render_frame_id,
-    const GURL& new_url) {
+    const GURL& new_url,
+    const ResourceRequestInfo::WebContentsGetter& web_contents_getter) {
   bool cancel = false;
   PrerenderContents* prerender_contents =
-      PrerenderContentsFromRenderFrame(render_process_id, render_frame_id);
+      PrerenderContentsFromGetter(web_contents_getter);
   if (prerender_contents) {
     prerender_contents->prerender_manager()->RecordPrefetchResponseReceived(
         prerender_contents->origin(),
         content::IsResourceTypeFrame(resource_type), true /* is_redirect */,
         is_no_store);
     // Abort any prerenders with requests which redirect to invalid schemes.
     if (!PrerenderManager::DoesURLHaveValidScheme(new_url)) {
       prerender_contents->Destroy(FINAL_STATUS_UNSUPPORTED_SCHEME);
       ReportUnsupportedPrerenderScheme(new_url);
       cancel = true;
@@ skipping 19 matching lines @@
       base::Bind(cancel ? &PrerenderResourceThrottle::Cancel
                         : &PrerenderResourceThrottle::ResumeHandler,
                  throttle));
 }
 
 // static
 void PrerenderResourceThrottle::WillProcessResponseOnUI(
     bool is_main_resource,
     bool is_no_store,
     int redirect_count,
-    int render_process_id,
-    int render_frame_id,
     scoped_refptr<PrerenderThrottleInfo> prerender_throttle_info) {
   DCHECK(prerender_throttle_info);
   if (!prerender_throttle_info->manager())
     return;
 
   if (prerender_throttle_info->mode() != PREFETCH_ONLY)
     return;
 
   prerender_throttle_info->manager()->RecordPrefetchResponseReceived(
       prerender_throttle_info->origin(), is_main_resource,
       false /* is_redirect */, is_no_store);
   prerender_throttle_info->manager()->RecordPrefetchRedirectCount(
       prerender_throttle_info->origin(), is_main_resource, redirect_count);
 }
 
 // static
-PrerenderContents* PrerenderResourceThrottle::PrerenderContentsFromRenderFrame(
-    int render_process_id, int render_frame_id) {
+PrerenderContents* PrerenderResourceThrottle::PrerenderContentsFromGetter(
+    const ResourceRequestInfo::WebContentsGetter& web_contents_getter) {
   if (g_prerender_contents_for_testing)
     return g_prerender_contents_for_testing;
-  content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
-      render_process_id, render_frame_id);
-  content::WebContents* web_contents =
-      content::WebContents::FromRenderFrameHost(rfh);
-  return PrerenderContents::FromWebContents(web_contents);
+  return PrerenderContents::FromWebContents(web_contents_getter.Run());
 }
 
 }  // namespace prerender