[PlzNavigate] Add load flags for prefetch navigations

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/web_contents.h"
+#include "net/base/load_flags.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 {
 
@@ skipping 50 matching lines @@
   base::WeakPtr<PrerenderManager> manager_;
 };
 
 void PrerenderResourceThrottle::OverridePrerenderContentsForTesting(
     PrerenderContents* contents) {
   g_prerender_contents_for_testing = contents;
 }
 
 PrerenderResourceThrottle::PrerenderResourceThrottle(net::URLRequest* request)
     : request_(request),
+      load_flags_(net::LOAD_NORMAL),
       prerender_throttle_info_(new PrerenderThrottleInfo()) {}
 
 PrerenderResourceThrottle::~PrerenderResourceThrottle() {}
 
 void PrerenderResourceThrottle::WillStartRequest(bool* defer) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
@@ skipping 36 matching lines @@
                  content::IsResourceTypeFrame(info->GetResourceType()),
                  IsNoStoreResponse(*request_), redirect_count,
                  prerender_throttle_info_));
 }
 
 const char* PrerenderResourceThrottle::GetNameForLogging() const {
   return "PrerenderResourceThrottle";
 }
 
 void PrerenderResourceThrottle::ResumeHandler() {
+  request_->SetLoadFlags(request_->load_flags() | load_flags_);
   Resume();
 }
 
 // static
 void PrerenderResourceThrottle::WillStartRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& method,
     ResourceType resource_type,
     const GURL& url,
     const ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     scoped_refptr<PrerenderThrottleInfo> prerender_throttle_info) {

[clamy, 2016/12/23 12:33:32]

nit: It'd be nice in the long run to have
DCHECK(CurrentlyOn(BrowserThread::{UI/IO}) in this code. This helps with
correctness and understanding what is happening.

[pasko, 2016/12/23 13:28:51]

With correctness - yes, probably should add these in the long run.

I am not sure how much it helps understanding in practice. We all know that
throttles live on IO thread. Static methods that have a suffix "OnUI" are
documenting this part, right?

[clamy, 2016/12/23 14:21:10]

That's why I'm marking this as a nit, it doesn't need to be done in this CL.

   bool cancel = false;
   PrerenderContents* prerender_contents =
       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());
+    BrowserThread::PostTask(

[clamy, 2016/12/23 12:33:31]

Rather than having two different PostTasks, why not pass the prerender mode as
an argument to ResumeHandler?

[pasko, 2016/12/23 13:28:51]

I had the same question, but then saw that ResumeHandler is also called in
ResumeThrottles() that runs on the IO thread without necessary context:

https://codesearch.chromium.org/chromium/src/chrome/browser/prerender/prerend...

[clamy, 2016/12/23 14:21:10]

Acknowledged.

+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&PrerenderResourceThrottle::SetPrerenderMode, throttle,
+                   prerender_contents->prerender_mode()));
 
     // 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);
@@ skipping 93 matching lines @@
 }
 
 // static
 PrerenderContents* PrerenderResourceThrottle::PrerenderContentsFromGetter(
     const ResourceRequestInfo::WebContentsGetter& web_contents_getter) {
   if (g_prerender_contents_for_testing)
     return g_prerender_contents_for_testing;
   return PrerenderContents::FromWebContents(web_contents_getter.Run());
 }
 
+void PrerenderResourceThrottle::SetPrerenderMode(PrerenderMode mode) {
+  load_flags_ = (mode == PREFETCH_ONLY) ? net::LOAD_PREFETCH : net::LOAD_NORMAL;
+}
+
 }  // namespace prerender