[Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY

content/browser/loader/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
@@ skipping 455 matching lines @@
     // is no current mechanism to prompt the user for their consent for a
     // re-post. For GETs, try to retrieve data from the cache and skip
     // validating the entry if present.
     if (request->get_upload() != NULL)
       extra_load_flags |= net::LOAD_ONLY_FROM_CACHE;
     else
       extra_load_flags |= net::LOAD_PREFERRING_CACHE;
   } else {
     extra_load_flags |= net::LOAD_DISABLE_CACHE;
   }
-  request->set_load_flags(request->load_flags() | extra_load_flags);
+  request->SetLoadFlags(request->load_flags() | extra_load_flags);
 
   // No need to get offline load flags for downloads, but make sure
   // we have an OfflinePolicy to receive request completions.
   GlobalRoutingID id(child_id, route_id);
   if (!offline_policy_map_[id])
     offline_policy_map_[id] = new OfflinePolicy();
 
   // Check if the renderer is permitted to request the requested URL.
   if (!ChildProcessSecurityPolicyImpl::GetInstance()->
           CanRequestURL(child_id, url)) {
@@ skipping 533 matching lines @@
   bool is_sync_load = sync_result != NULL;
   int load_flags =
       BuildLoadFlagsForRequest(request_data, child_id, is_sync_load);
 
   GlobalRoutingID id(child_id, route_id);
   if (!offline_policy_map_[id])
     offline_policy_map_[id] = new OfflinePolicy();
   load_flags |= offline_policy_map_[id]->GetAdditionalLoadFlags(
       load_flags, request_data.resource_type == ResourceType::MAIN_FRAME);
 
+  // Sync loads should have maximum priority and should be the only
+  // requets that have the ignore limits flag set.
+  if (is_sync_load) {
+    DCHECK_EQ(request_data.priority, net::MAXIMUM_PRIORITY);
+    DCHECK_NE(load_flags & net::LOAD_IGNORE_LIMITS, 0);
+  } else {
+    DCHECK_EQ(load_flags & net::LOAD_IGNORE_LIMITS, 0);
+  }
+
   // Construct the request.
   scoped_ptr<net::URLRequest> new_request;
   net::URLRequest* request;
   new_request = request_context->CreateRequest(
       request_data.url, request_data.priority, NULL);
   request = new_request.get();
 
   request->set_method(request_data.method);
   request->set_first_party_for_cookies(request_data.first_party_for_cookies);
   SetReferrerForRequest(request, referrer);
 
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(request_data.headers);
   request->SetExtraRequestHeaders(headers);
 
-  request->set_load_flags(load_flags);
+  request->SetLoadFlags(load_flags);
 
   // Resolve elements from request_body and prepare upload data.
   if (request_data.request_body.get()) {
     webkit_blob::BlobStorageContext* blob_context = NULL;
     if (filter_->blob_storage_context())
       blob_context = filter_->blob_storage_context()->context();
     request->set_upload(UploadDataStreamBuilder::Build(
         request_data.request_body.get(),
         blob_context,
         filter_->file_system_context(),
@@ skipping 222 matching lines @@
     return;
   }
 
   scoped_ptr<net::URLRequest> request(
       request_context->CreateRequest(url, net::DEFAULT_PRIORITY, NULL));
   request->set_method("GET");
   SetReferrerForRequest(request.get(), referrer);
 
   // So far, for saving page, we need fetch content from cache, in the
   // future, maybe we can use a configuration to configure this behavior.
-  request->set_load_flags(net::LOAD_PREFERRING_CACHE);
+  request->SetLoadFlags(net::LOAD_PREFERRING_CACHE);
 
   // No need to get offline load flags for save files, but make sure
   // we have an OfflinePolicy to receive request completions.
   GlobalRoutingID id(child_id, route_id);
   if (!offline_policy_map_[id])
     offline_policy_map_[id] = new OfflinePolicy();
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceRequestInfoImpl* extra_info =
       CreateRequestInfo(child_id, route_id, false, context);
@@ skipping 266 matching lines @@
 
 void ResourceDispatcherHostImpl::BeginRequestInternal(
     scoped_ptr<net::URLRequest> request,
     scoped_ptr<ResourceHandler> handler) {
   DCHECK(!request->is_pending());
   ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request.get());
 
   if ((TimeTicks::Now() - last_user_gesture_time_) <
       TimeDelta::FromMilliseconds(kUserGestureWindowMs)) {
-    request->set_load_flags(
+    request->SetLoadFlags(
         request->load_flags() | net::LOAD_MAYBE_USER_GESTURE);
   }
 
   // Add the memory estimate that starting this request will consume.
   info->set_memory_cost(CalculateApproximateMemoryCost(request.get()));
 
   // If enqueing/starting this request will exceed our per-process memory
   // bound, abort it right away.
   OustandingRequestsStats stats = IncrementOutstandingRequestsMemory(1, *info);
   if (stats.memory_cost > max_outstanding_requests_cost_per_process_) {
@@ skipping 329 matching lines @@
   if ((load_flags & net::LOAD_REPORT_RAW_HEADERS)
       && !policy->CanReadRawCookies(child_id)) {
     VLOG(1) << "Denied unauthorized request for raw headers";
     load_flags &= ~net::LOAD_REPORT_RAW_HEADERS;
   }
 
   return load_flags;
 }
 
 }  // namespace content