[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),
-      prerender_throttle_info_(new PrerenderThrottleInfo()) {}
+      prerender_throttle_info_(new PrerenderThrottleInfo()) {
+// 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);
+  } else if (request_->priority() != net::IDLE) {
+    original_request_priority_ = request_->priority();
+    // In practice, the resource scheduler does not know about the request yet,
+    // and it falls back to calling request_->SetPriority(), so it would be
+    // possible to do just that here. It is cleaner and more robust to go
+    // through the resource dispatcher host though.
+    if (content::ResourceDispatcherHost::Get()) {
+      content::ResourceDispatcherHost::Get()->ReprioritizeRequest(request_,
+                                                                  net::IDLE);
+    }
+  }
+#endif  // OS_ANDROID
+}
 
 PrerenderResourceThrottle::~PrerenderResourceThrottle() {}
 
 void PrerenderResourceThrottle::WillStartRequest(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   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(), 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_)
+    return;
+
+  if (content::ResourceDispatcherHost::Get()) {
+    content::ResourceDispatcherHost::Get()->ReprioritizeRequest(
+        request_, original_request_priority_.value());
+  }
+}
+
 // 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 33 matching lines @@
         // 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);
+
+      // No need 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