prerender: Don't set the priority to net::IDLE on Android.

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.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/loader/chrome_resource_dispatcher_host_delegate.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 235 matching lines @@
   } else {
     ExternalProtocolHandler::LaunchUrlWithDelegate(
         url, render_process_id, web_contents->GetRoutingID(), page_transition,
         has_user_gesture, g_external_protocol_handler_delegate);
   }
 }
 
 #if !defined(DISABLE_NACL)
 void AppendComponentUpdaterThrottles(
     net::URLRequest* request,
+    const ResourceRequestInfo& info,
     content::ResourceContext* resource_context,
     ResourceType resource_type,
     ScopedVector<content::ResourceThrottle>* throttles) {
+  bool is_prerendering =
+      info.GetVisibilityState() == blink::WebPageVisibilityStatePrerender;
+  if (is_prerendering)
+    return;
+
   const char* crx_id = NULL;
   component_updater::ComponentUpdateService* cus =
       g_browser_process->component_updater();
   if (!cus)
     return;
   // Check for PNaCl pexe request.
   if (resource_type == content::RESOURCE_TYPE_OBJECT) {
     const net::HttpRequestHeaders& headers = request->extra_request_headers();
     std::string accept_headers;
     if (headers.GetHeader("Accept", &accept_headers)) {
@@ skipping 146 matching lines @@
 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::AppCacheService* appcache_service,
     ResourceType resource_type,
     ScopedVector<content::ResourceThrottle>* throttles) {
   if (safe_browsing_.get())
     safe_browsing_->OnResourceRequest(request);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+
+// The lowering of request priority causes issues with scheduling, since
+// content::ResourceScheduler uses it to delay and throttle requests. This is
+// disabled only on Android, as the prerenders are not likely to compete with
+// page loads there.
+// See https://crbug.com/652746 for details.
+// TODO(lizeb,droger): Fix the issue on all platforms.
+#if !defined(OS_ANDROID)
   bool is_prerendering =
       info->GetVisibilityState() == blink::WebPageVisibilityStatePrerender;
   if (is_prerendering) {
     // 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 {
       request->SetPriority(net::IDLE);
     }
   }
+#endif  // OS_ANDROID
 
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(
       resource_context);
 
 #if defined(OS_ANDROID)
   if (resource_type != content::RESOURCE_TYPE_MAIN_FRAME)
     InterceptNavigationDelegate::UpdateUserGestureCarryoverInfo(request);
 #endif
 
 #if defined(OS_CHROMEOS)
@@ skipping 29 matching lines @@
 
   signin::FixMirrorRequestHeaderHelper(request, GURL() /* redirect_url */,
                                        io_data, info->GetChildID(),
                                        info->GetRouteID());
 
   AppendStandardResourceThrottles(request,
                                   resource_context,
                                   resource_type,
                                   throttles);
 #if !defined(DISABLE_NACL)
-  if (!is_prerendering) {
-    AppendComponentUpdaterThrottles(request,
-                                    resource_context,
-                                    resource_type,
-                                    throttles);
-  }
-#endif
+  AppendComponentUpdaterThrottles(request, *info, resource_context,
+                                  resource_type, throttles);
+#endif  // !defined(DISABLE_NACL)
 
   if (io_data->resource_prefetch_predictor_observer()) {
     io_data->resource_prefetch_predictor_observer()->OnRequestStarted(
         request, resource_type, info->GetChildID(), info->GetRenderFrameID());
   }
 }
 
 void ChromeResourceDispatcherHostDelegate::DownloadStarting(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
@@ skipping 359 matching lines @@
           base::Bind(&ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad,
                     base::Unretained(this), url, request_loading_time));
       return;
   }
 
   std::string metric_name = (request_loading_time.InMilliseconds() < 100 ?
       "Net.ErrAborted.Fast" : "Net.ErrAborted.Slow");
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(), metric_name, url);
 }