[Prerender] Restore request priorities when swapped in

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/resource_dispatcher_host.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;
 
@@ skipping 53 matching lines @@
 };
 
 void PrerenderResourceThrottle::OverridePrerenderContentsForTesting(
     PrerenderContents* contents) {
   g_prerender_contents_for_testing = contents;
 }
 
 PrerenderResourceThrottle::PrerenderResourceThrottle(net::URLRequest* request)
     : request_(request),
       load_flags_(net::LOAD_NORMAL),
+      original_request_priority_(net::IDLE),
       prerender_throttle_info_(new PrerenderThrottleInfo()) {}
 
 PrerenderResourceThrottle::~PrerenderResourceThrottle() {}
 
 void PrerenderResourceThrottle::WillStartRequest(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
+
+// Priorities for prerendering requests are lowered, to avoid competing with
+// other page loads, except on Android where this is less likely to be a
+// problem. In some cases, this may negatively impact the performance of
+// prerendering, see https://crbug.com/652746 for details.
+#if !defined(OS_ANDROID)
+  // Requests with the IGNORE_LIMITS flag set (i.e., sync XHRs)
+  // should remain at MAXIMUM_PRIORITY.
+  if (request_->load_flags() & net::LOAD_IGNORE_LIMITS) {
+    DCHECK_EQ(request_->priority(), net::MAXIMUM_PRIORITY);
+    // original_request_priority_ can be kept to IDLE, so that the priority will
+    // never be touched again.
+  } else if (request_->priority() != net::IDLE) {
+    original_request_priority_ = request_->priority();
+    content::ResourceDispatcherHost::Get()->ReprioritizeRequest(request_,
+                                                                net::IDLE);
+  }
+#endif  // OS_ANDROID
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillStartRequestOnUI, AsWeakPtr(),
                  request_->method(), info->GetResourceType(), request_->url(),
                  info->GetWebContentsGetterForRequest(),
                  prerender_throttle_info_));
 }
 
 void PrerenderResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
@@ skipping 35 matching lines @@
 const char* PrerenderResourceThrottle::GetNameForLogging() const {
   return "PrerenderResourceThrottle";
 }
 
 void PrerenderResourceThrottle::ResumeHandler() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   request_->SetLoadFlags(request_->load_flags() | load_flags_);
   Resume();
 }
 
+void PrerenderResourceThrottle::ResetResourcePriority() {
+  if (original_request_priority_ == net::IDLE) {
+    // IDLE means that the original request was either IDLE or must not be
+    // changed.

[Charlie Harrison, 2017/04/12 12:37:26]

You could use a base::Optional to make this distinction more clear.

[droger, 2017/04/12 13:20:54]

Done.

+    return;
+  }
+
+  content::ResourceDispatcherHost::Get()->ReprioritizeRequest(
+      request_, original_request_priority_);
+}
+
 // 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) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool cancel = false;
@@ skipping 32 matching lines @@
         // 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);

[Charlie Harrison, 2017/04/12 12:37:26]

nit: newline below

[droger, 2017/04/12 13:20:54]

Done.

+      // No need to add to call AddIdleResource() on Android.
       return;
 #endif
     }
+
+#if !defined(OS_ANDROID)
+    if (!cancel)
+      prerender_contents->AddIdleResource(throttle);
+#endif
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(cancel ? &PrerenderResourceThrottle::Cancel
                         : &PrerenderResourceThrottle::ResumeHandler,
                  throttle));
 }
 
 // static
@@ skipping 72 matching lines @@
     return g_prerender_contents_for_testing;
   return PrerenderContents::FromWebContents(web_contents_getter.Run());
 }
 
 void PrerenderResourceThrottle::SetPrerenderMode(PrerenderMode mode) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   load_flags_ = (mode == PREFETCH_ONLY) ? net::LOAD_PREFETCH : net::LOAD_NORMAL;
 }
 
 }  // namespace prerender