Change SupportsSpdy dict, SpdySettingsMap, ServerNetworkStatsMap, AlternativeServiceMap and disk da…

content/browser/loader/resource_scheduler.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 "content/browser/loader/resource_scheduler.h"
 
 #include <stdint.h>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/supports_user_data.h"
 #include "content/common/resource_messages.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/resource_throttle.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
+#include "url/scheme_host_port.h"
 
 namespace content {
 
 namespace {
 
 enum StartMode {
   START_SYNC,
   START_ASYNC
 };
 
@@ skipping 457 matching lines @@
                request->url_request()->priority() >
                scheduler_->non_delayable_threshold()) {
       // Requests that are above the non_delayable threshold before the HTML
       // body has been parsed are inferred to be layout-blocking.
       attributes |= kAttributeLayoutBlocking;
     } else if (request->url_request()->priority() <
                scheduler_->non_delayable_threshold()) {
       // Resources below the non_delayable_threshold that are being requested
       // from a server that does not support native prioritization are
       // considered delayable.
-      net::HostPortPair host_port_pair =
-          net::HostPortPair::FromURL(request->url_request()->url());
+      url::SchemeHostPort scheme_host_port(request->url_request()->url());
       net::HttpServerProperties& http_server_properties =
           *request->url_request()->context()->http_server_properties();
-      if (!http_server_properties.SupportsRequestPriority(host_port_pair))
+      if (!http_server_properties.SupportsRequestPriority(scheme_host_port))
         attributes |= kAttributeDelayable;
     }
 
     return attributes;
   }
 
   bool ShouldKeepSearching(
       const net::HostPortPair& active_request_host) const {
     size_t same_host_count = 0;
     for (RequestSet::const_iterator it = in_flight_requests_.begin();
@@ skipping 68 matching lines @@
       return START_REQUEST;
 
     // Implementation of the kRequestLimitFieldTrial.
     if (scheduler_->limit_outstanding_requests() &&
         in_flight_requests_.size() >= scheduler_->outstanding_request_limit()) {
       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
 
     net::HostPortPair host_port_pair =
         net::HostPortPair::FromURL(url_request.url());
+    url::SchemeHostPort scheme_host_port(url_request.url());
     net::HttpServerProperties& http_server_properties =
         *url_request.context()->http_server_properties();
 
     // TODO(willchan): We should really improve this algorithm as described in
     // crbug.com/164101. Also, theoretically we should not count a
     // request-priority capable request against the delayable requests limit.
-    if (http_server_properties.SupportsRequestPriority(host_port_pair))
+    if (http_server_properties.SupportsRequestPriority(scheme_host_port))
       return START_REQUEST;
 
     // Non-delayable requests.
     if (!RequestAttributesAreSet(request->attributes(), kAttributeDelayable))
       return START_REQUEST;
 
     if (in_flight_delayable_count_ >=
         scheduler_->max_num_delayable_requests()) {
       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
@@ skipping 341 matching lines @@
   client->ReprioritizeRequest(scheduled_resource_request, old_priority_params,
                               new_priority_params);
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content