Fix Resource Priorities and Scheduling (Chrome Side)

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"

[mmenke, 2015/08/11 17:57:23]

Add blank line after this include.

[Pat Meenan, 2015/08/12 16:20:59]

Done.

 #include <set>
 
-#include "content/browser/loader/resource_scheduler.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/time/time.h"
 #include "content/common/resource_messages.h"
 #include "content/browser/loader/resource_message_delegate.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
@@ skipping 11 matching lines @@
 namespace {
 
 // Field trial constants
 const char kThrottleCoalesceFieldTrial[] = "RequestThrottlingAndCoalescing";
 const char kThrottleCoalesceFieldTrialThrottle[] = "Throttle";
 const char kThrottleCoalesceFieldTrialCoalesce[] = "Coalesce";
 
 const char kRequestLimitFieldTrial[] = "OutstandingRequestLimiting";
 const char kRequestLimitFieldTrialGroupPrefix[] = "Limit";
 
+const char kResourcePrioritiesFieldTrial[] = "ResourcePriorities";
+
 // Post ResourceScheduler histograms of the following forms:
 // If |histogram_suffix| is NULL or the empty string:
 //   ResourceScheduler.base_name.histogram_name
 // Else:
 //   ResourceScheduler.base_name.histogram_name.histogram_suffix
 void PostHistogram(const char* base_name,
                    const char* histogram_name,
                    const char* histogram_suffix,
                    base::TimeDelta time) {
   std::string histogram =
@@ skipping 17 matching lines @@
   else if (num_clients <= 15)
     return "Max15Clients";
   else if (num_clients <= 30)
     return "Max30Clients";
   return "Over30Clients";
 }
 
 }  // namespace
 
 static const size_t kCoalescedTimerPeriod = 5000;
-static const size_t kMaxNumDelayableRequestsPerClient = 10;
+static const size_t kDefaultMaxNumDelayableRequestsPerClient = 10;
 static const size_t kMaxNumDelayableRequestsPerHost = 6;
 static const size_t kMaxNumThrottledRequestsPerClient = 1;
+static const size_t kDefaultMaxNumDelayableWhileLayoutBlocking = 1;
+static const net::RequestPriority
+    kDefaultLayoutBlockingPriorityThreshold = net::LOW;
 
 struct ResourceScheduler::RequestPriorityParams {
   RequestPriorityParams()
     : priority(net::DEFAULT_PRIORITY),
       intra_priority(0) {
   }
 
   RequestPriorityParams(net::RequestPriority priority, int intra_priority)
     : priority(priority),
       intra_priority(intra_priority) {
@@ skipping 206 matching lines @@
   DCHECK(!ContainsKey(pointers_, request));
   request->set_fifo_ordering(MakeFifoOrderingId());
   pointers_[request] = queue_.insert(request);
 }
 
 // Each client represents a tab.
 class ResourceScheduler::Client {
  public:
   explicit Client(ResourceScheduler* scheduler,
                   bool is_visible,
-                  bool is_audible)
+                  bool is_audible,
+                  net::RequestPriority layout_blocking_priority_threshold,
+                  bool enable_layout_blocking_threshold,
+                  size_t in_flight_layout_blocking_threshold,
+                  size_t max_num_delayable_while_layout_blocking,
+                  size_t max_num_delayable_requests)

[mmenke, 2015/08/11 17:57:23]

I was actually thinking these could all be grabbed from the scheduler...  i.e.
scheduler_->max_num_delayable_while_layout_blocking(), since these don't vary on
a per-client basis, and that pattern is already used elsewhere (e.g.
scheduler_->limit_outstanding_requests()).

[Pat Meenan, 2015/08/12 16:20:59]

Done.

       : is_audible_(is_audible),
         is_visible_(is_visible),
         is_loaded_(false),
         is_paused_(false),
-        has_body_(false),
+        has_html_body_(false),
         using_spdy_proxy_(false),
         load_started_time_(base::TimeTicks::Now()),
         scheduler_(scheduler),
         in_flight_delayable_count_(0),
         total_layout_blocking_count_(0),
-        throttle_state_(ResourceScheduler::THROTTLED) {}
+        throttle_state_(ResourceScheduler::THROTTLED),
+        max_num_delayable_requests_(max_num_delayable_requests),
+        max_num_delayable_while_layout_blocking_(
+            max_num_delayable_while_layout_blocking),
+        enable_layout_blocking_threshold_(enable_layout_blocking_threshold),
+        in_flight_layout_blocking_threshold_(
+            in_flight_layout_blocking_threshold),
+        layout_blocking_priority_threshold_(
+            layout_blocking_priority_threshold) {
+  }
 
   ~Client() {
     // Update to default state and pause to ensure the scheduler has a
     // correct count of relevant types of clients.
     is_visible_ = false;
     is_audible_ = false;
     is_paused_ = true;
     UpdateThrottleState();
   }
 
@@ skipping 15 matching lines @@
       EraseInFlightRequest(request);
 
       // Removing this request may have freed up another to load.
       LoadAnyStartablePendingRequests();
     }
   }
 
   RequestSet StartAndRemoveAllRequests() {
     // First start any pending requests so that they will be moved into
     // in_flight_requests_. This may exceed the limits
-    // kMaxNumDelayableRequestsPerClient, kMaxNumDelayableRequestsPerHost and
-    // kMaxNumThrottledRequestsPerClient, so this method must not do anything
-    // that depends on those limits before calling ClearInFlightRequests()
-    // below.
+    // kDefaultMaxNumDelayableRequestsPerClient, kMaxNumDelayableRequestsPerHost
+    // and kMaxNumThrottledRequestsPerClient, so this method must not do
+    // anything that depends on those limits before calling
+    // ClearInFlightRequests() below.
     while (!pending_requests_.IsEmpty()) {
       ScheduledResourceRequest* request =
           *pending_requests_.GetNextHighestIterator();
       pending_requests_.Erase(request);
       // StartRequest() may modify pending_requests_. TODO(ricea): Does it?
       StartRequest(request);
     }
     RequestSet unowned_requests;
     for (RequestSet::iterator it = in_flight_requests_.begin();
          it != in_flight_requests_.end(); ++it) {
@@ skipping 96 matching lines @@
       scheduler_->DecrementActiveClientsLoading();
     }
     if (throttle_state_ == COALESCED) {
       scheduler_->IncrementCoalescedClients();
     } else if (old_throttle_state == COALESCED) {
       scheduler_->DecrementCoalescedClients();
     }
   }
 
   void OnNavigate() {
-    has_body_ = false;
+    has_html_body_ = false;
     is_loaded_ = false;
   }
 
   void OnWillInsertBody() {
-    has_body_ = true;
+    has_html_body_ = true;
     LoadAnyStartablePendingRequests();
   }
 
   void OnReceivedSpdyProxiedHttpResponse() {
     if (!using_spdy_proxy_) {
       using_spdy_proxy_ = true;
       LoadAnyStartablePendingRequests();
     }
   }
 
@@ skipping 129 matching lines @@
         CountRequestsWithClassification(IN_FLIGHT_DELAYABLE_REQUEST, false),
         in_flight_delayable_count_);
     DCHECK_EQ(CountRequestsWithClassification(LAYOUT_BLOCKING_REQUEST, true),
               total_layout_blocking_count_);
   }
 
   RequestClassification ClassifyRequest(ScheduledResourceRequest* request) {
     // If a request is already marked as layout-blocking make sure to keep the
     // classification across redirects unless the priority was lowered.
     if (request->classification() == LAYOUT_BLOCKING_REQUEST &&
-        request->url_request()->priority() > net::LOW) {
+        request->url_request()->priority() >
+        layout_blocking_priority_threshold_) {

[mmenke, 2015/08/11 17:57:23]

While we're here, is the second condition really needed?  Seems like it could
just be a DCHECK, if we really wanted to keep it.

[Pat Meenan, 2015/08/12 16:20:59]

Done.

       return LAYOUT_BLOCKING_REQUEST;
     }
 
-    if (!has_body_ && request->url_request()->priority() > net::LOW)
+    if (!has_html_body_ &&
+        request->url_request()->priority() >
+        layout_blocking_priority_threshold_) {
       return LAYOUT_BLOCKING_REQUEST;

[mmenke, 2015/08/11 17:57:23]

Having our enum names depend on deducing information on what blink is doing
based on a deep understanding of blink's prioritization mapping seems like a
huge layering violation.  I can't really validate the code is correct without
that understanding.  If blink sent us a layout blocking bit, and we just used
that, I'd feel differently.

EARLY_IMMEDIATE_REQUESTS?  EARLY_NON_DELAYABLE_REQUESTS?  Both go well with
"delayable", and make for a clearer difference between non-EARLY_REQUESTS (A
classification this doesn't actually return, but we do implicitly have, and are
currently called high priority requests, which is a bit bad, because there is a
HIGH priority, but we classify MEDIUM and even LOW priority requests as
high-priority requests).

[Pat Meenan, 2015/08/12 16:20:59]

It's a bit more complicated because there's also special logic associated with
this enum.  We stay in "layout-blocking" loading mode until we both got the HTML
body and all of the layout-blocking requests have finished.  It's also not ALL
non-delayable requests, just those that are over the threshold.  The ones that
== the threshold are neither layout-blocking nor delayable.

These requests keep us in the holdback mode so I'd be fine renaming it to
something clearer but for better or worse we're currently referring that to
layout-blocking mode because we're loading resources that are preventing the
first page layout.  An explicit bit from blink should be easy enough but I think
we're always going to have a piece somewhere between blink and the raw net stack
that understands both worlds and does prioritization that is content-specific,
tab-aware (visible/hidden) and in the not-too-distant future iframe-aware.

[mmenke, 2015/08/12 16:31:06]

Talking on another thread about getting this information from the renderer,
which would make me much happier...  Let's leave it alone for now.

+    }
 
-    if (request->url_request()->priority() < net::LOW) {
-      net::HostPortPair host_port_pair =
-          net::HostPortPair::FromURL(request->url_request()->url());
-      net::HttpServerProperties& http_server_properties =
-          *request->url_request()->context()->http_server_properties();
-      if (!http_server_properties.SupportsRequestPriority(host_port_pair) &&
-          ContainsKey(in_flight_requests_, request)) {
-        return IN_FLIGHT_DELAYABLE_REQUEST;
-      }
+    if (request->url_request()->priority() <
+        layout_blocking_priority_threshold_ &&
+        ContainsKey(in_flight_requests_, request)) {
+      return IN_FLIGHT_DELAYABLE_REQUEST;

[mmenke, 2015/08/11 17:57:23]

I don't think the SPDY change belongs in this CL.  Fine with landing it first
(should be fast) or second.

[Pat Meenan, 2015/08/12 16:21:00]

Agreed.  We'll address this separately because there's a bigger issue of SPDY
request prioritization when a page spans multiple hosts (or mixes SPDY/HTTP1).

     }
     return NORMAL_REQUEST;
   }
 
   bool ShouldKeepSearching(
       const net::HostPortPair& active_request_host) const {
     size_t same_host_count = 0;
     for (RequestSet::const_iterator it = in_flight_requests_.begin();
          it != in_flight_requests_.end(); ++it) {
       net::HostPortPair host_port_pair =
@@ skipping 84 matching lines @@
     if (throttle_state_ == COALESCED) {
       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
 
     if (using_spdy_proxy_ && url_request.url().SchemeIs(url::kHttpScheme)) {
       return START_REQUEST;
     }
 
     // Implementation of the kRequestLimitFieldTrial.
     if (scheduler_->limit_outstanding_requests() &&
         in_flight_requests_.size() >= scheduler_->outstanding_request_limit()) {

[mmenke, 2015/08/11 17:57:23]

Note that you may run into this experiment, which also sets
limit_outstanding_requests() to true.

[Pat Meenan, 2015/08/12 16:20:59]

Acknowledged.

       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
 
     net::HostPortPair host_port_pair =
         net::HostPortPair::FromURL(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)) {
       return START_REQUEST;
     }
 
     if (throttle_state_ == THROTTLED &&
         in_flight_requests_.size() >= kMaxNumThrottledRequestsPerClient) {
       // There may still be request-priority-capable requests that should be
       // issued.
       return DO_NOT_START_REQUEST_AND_KEEP_SEARCHING;
     }
 
     // High-priority and layout-blocking requests.
-    if (url_request.priority() >= net::LOW) {
+    if (url_request.priority() >= layout_blocking_priority_threshold_) {

[mmenke, 2015/08/11 17:57:23]

This is kinda weird...We're looking at the layout blocking threshold, but
url_request may not be layout blocking, based on when it was started.  Should it
be immediate_request_threshold_ / non_delayable_request_threshold_ - see earlier
comment.

[Pat Meenan, 2015/08/12 16:21:00]

I can rename this if we come to a decision on what we want to call the line that
we're using to determine what we currently classify as layout-blocking.

       return START_REQUEST;
     }
 
-    if (in_flight_delayable_count_ >= kMaxNumDelayableRequestsPerClient) {
+    if (in_flight_delayable_count_ >= max_num_delayable_requests_) {
       return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
     }
 
     if (ShouldKeepSearching(host_port_pair)) {
       // There may be other requests for other hosts we'd allow,
       // so keep checking.
       return DO_NOT_START_REQUEST_AND_KEEP_SEARCHING;
     }
 
-    bool have_immediate_requests_in_flight =
-        in_flight_requests_.size() > in_flight_delayable_count_;
-    if (have_immediate_requests_in_flight &&
-        (!has_body_ || total_layout_blocking_count_ != 0) &&
-        // Do not allow a low priority request through in parallel if
-        // we are in a limit field trial.
-        (scheduler_->limit_outstanding_requests() ||
-         in_flight_delayable_count_ != 0)) {
-      return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+    // Layout-blocking phase of resource loading.
+    if (!has_html_body_ || total_layout_blocking_count_ != 0) {
+      size_t non_delayable_requests_in_flight_count =
+          in_flight_requests_.size() - in_flight_delayable_count_;
+      if (enable_layout_blocking_threshold_) {
+        if (non_delayable_requests_in_flight_count >
+            in_flight_layout_blocking_threshold_) {
+          // Too many higher priority in-flight requests to allow lower priority
+          // requests through.
+          return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+        }
+        if (in_flight_requests_.size() > 0 &&
+            // Allow the request if nothing is in flight or if the limit of

[mmenke, 2015/08/11 17:57:23]

This should probably say "block the request if..."

[Pat Meenan, 2015/08/12 16:20:59]

Done.

+            // concurrent lower priority requests has not been hit.

[mmenke, 2015/08/11 17:57:23]

This should either before the if, or inside the if's body - it describes the
line before it as well as next two conditions.

[Pat Meenan, 2015/08/12 16:20:59]

Done.

+            (scheduler_->limit_outstanding_requests() ||
+             in_flight_delayable_count_ >=
+             max_num_delayable_while_layout_blocking_)) {

[mmenke, 2015/08/11 19:27:28]

max_num_delayable_while_layout_blocking_ is used with >=, while
in_flight_layout_blocking_threshold_ is used with >.  This seems inconsistent.

[Pat Meenan, 2015/08/12 16:20:59]

They have slightly different behaviors which is why the names are different (max
vs threshold).  Max is a saturation point and you'd never expect to exceed it. 
In the case of the threshold, once the number of in-flight immediate requests
drops down to (or below) that value we start allowing lower priority requests
through.

In this case the request being checked is delayable and directly impacts the
max_num_delayable result while the threshold is checking the state of other
request priorities before determining if it should let this one through.

I might be able to switch the "threshold" to a
"min_num_immediate_to_allow_delayable" or something like that to make it clearer
but it would still be the same comparison.

+          return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+        }
+      } else if (non_delayable_requests_in_flight_count > 0 &&
+          // If there are no high-priority requests in flight the floodgates
+          // open.
+          // If there are high-priority requests in-flight then limit the number
+          // of lower-priority requests (or zero if a limit field trial is
+          // active).

[mmenke, 2015/08/11 17:57:23]

Again, this should either before the if, or inside the if's body.

[Pat Meenan, 2015/08/12 16:20:59]

Done.

+          (scheduler_->limit_outstanding_requests() ||
+           in_flight_delayable_count_ >=
+           max_num_delayable_while_layout_blocking_)) {
+        return DO_NOT_START_REQUEST_AND_STOP_SEARCHING;
+      }
     }
 
     return START_REQUEST;
   }
 
   void LoadAnyStartablePendingRequests() {
     // We iterate through all the pending requests, starting with the highest
     // priority one. For each entry, one of three things can happen:
     // 1) We start the request, remove it from the list, and keep checking.
     // 2) We do NOT start the request, but ShouldStartRequest() signals us that
@@ skipping 26 matching lines @@
         DCHECK(query_result == DO_NOT_START_REQUEST_AND_STOP_SEARCHING);
         break;
       }
     }
   }
 
   bool is_audible_;
   bool is_visible_;
   bool is_loaded_;
   bool is_paused_;
-  bool has_body_;
+  // Tracks if the main HTML parser has reached the body which marks the end of
+  // layout-blocking resources.
+  bool has_html_body_;
   bool using_spdy_proxy_;
   RequestQueue pending_requests_;
   RequestSet in_flight_requests_;
   base::TimeTicks load_started_time_;
   // The last time the client switched state between active and background.
   base::TimeTicks last_active_switch_time_;
   ResourceScheduler* scheduler_;
   // The number of delayable in-flight requests.
   size_t in_flight_delayable_count_;
   // The number of layout-blocking in-flight requests.
   size_t total_layout_blocking_count_;
   ResourceScheduler::ClientThrottleState throttle_state_;
+  // Maximum number of delayable requests to allow at a time, regardless of
+  // the number of servers (limit to X concurrent requests across all hosts).
+  size_t max_num_delayable_requests_;
+  // Maximum number of delayable requests to allow while in the layout-blocking
+  // phase of resource loading.
+  size_t max_num_delayable_while_layout_blocking_;
+  // Determines if in_flight_layout_blocking_threshold_ should be used.
+  bool enable_layout_blocking_threshold_;
+  // Number number of non-delayable requests above which no delayable requests
+  // should be issued while in the layout-blocking phase of resource loading.
+  size_t in_flight_layout_blocking_threshold_;
+  // Priority level above which resources are considered layout-blocking and
+  // below which they are considered delayable.
+  net::RequestPriority layout_blocking_priority_threshold_;
 };
 
 ResourceScheduler::ResourceScheduler()
     : should_coalesce_(false),
       should_throttle_(false),
       active_clients_loading_(0),
       coalesced_clients_(0),
       limit_outstanding_requests_(false),
       outstanding_request_limit_(0),
+      layout_blocking_priority_threshold_(
+          kDefaultLayoutBlockingPriorityThreshold),
+      enable_layout_blocking_threshold_(false),
+      in_flight_layout_blocking_threshold_(0),
+      max_num_delayable_while_layout_blocking_(
+          kDefaultMaxNumDelayableWhileLayoutBlocking),
+      max_num_delayable_requests_(kDefaultMaxNumDelayableRequestsPerClient),
       coalescing_timer_(new base::Timer(true /* retain_user_task */,
                                         true /* is_repeating */)) {
   std::string throttling_trial_group =
       base::FieldTrialList::FindFullName(kThrottleCoalesceFieldTrial);
   if (throttling_trial_group == kThrottleCoalesceFieldTrialThrottle) {
     should_throttle_ = true;
   } else if (throttling_trial_group == kThrottleCoalesceFieldTrialCoalesce) {
     should_coalesce_ = true;
     should_throttle_ = true;
   }
 
   std::string outstanding_limit_trial_group =
       base::FieldTrialList::FindFullName(kRequestLimitFieldTrial);
   std::vector<std::string> split_group(
       base::SplitString(outstanding_limit_trial_group, "=",
                         base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL));
   int outstanding_limit = 0;
   if (split_group.size() == 2 &&
       split_group[0] == kRequestLimitFieldTrialGroupPrefix &&
       base::StringToInt(split_group[1], &outstanding_limit) &&
       outstanding_limit > 0) {
     limit_outstanding_requests_ = true;
     outstanding_request_limit_ = outstanding_limit;
   }
+
+  // Set up the ResourceScheduling field trial options.
+  // The field trial parameters are also encoded into the group name since
+  // the variations component is not available from here and plumbing the
+  // options through the code is overkill for a short experiment.
+  //
+  // The group name encoding looks like this:
+  //  <descriptiveName>_ABCDE_E2_F_G
+  //    A - fetchDeferLateScripts (1 for true, 0 for false)
+  //    B - fetchIncreaseFontPriority (1 for true, 0 for false)
+  //    C - fetchIncreaseAsyncScriptPriority (1 for true, 0 for false)
+  //    D - fetchIncreasePriorities (1 for true, 0 for false)

[mmenke, 2015/08/11 19:27:28]

I suggest an underscore between D and E, to separate out those that affect blink
from those that affect the scheduler.  Could even use different delimiters,
though I suppose just using one is simpler.

[Pat Meenan, 2015/08/12 16:20:59]

Though D is also a special case because it affects both.  I basically set it up
so that the first block was all of the bit fields that turn things on and off
regardless of where the implementation had to be and the trailing values after
the underscores were for the settings that had explicit numeric values.

+  //    E - fetchEnableLayoutBlockingThreshold (1 for true, 0 for false)
+  //    E2 - fetchLayoutBlockingThreshold (Numeric)
+  //    F - fetchMaxNumDelayableWhileLayoutBlocking (Numeric)
+  //    G - fetchMaxNumDelayableRequests (Numeric)
+  std::string resource_priorities_trial_group =
+      base::FieldTrialList::FindFullName(kResourcePrioritiesFieldTrial);
+  std::vector<std::string> resource_priorities_split_group(
+      base::SplitString(resource_priorities_trial_group, "_",
+                        base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL));
+  if (resource_priorities_split_group.size() == 5 &&
+      resource_priorities_split_group[1].length() == 5) {
+    // fetchIncreasePriorities
+    if (resource_priorities_split_group[1].at(3) == '1')
+      layout_blocking_priority_threshold_ = net::MEDIUM;
+    enable_layout_blocking_threshold_ =
+        resource_priorities_split_group[1].at(4) == '1';
+    size_t numeric_value = 0;
+    if (base::StringToSizeT(resource_priorities_split_group[2], &numeric_value))
+      in_flight_layout_blocking_threshold_ = numeric_value;
+    if (base::StringToSizeT(resource_priorities_split_group[3], &numeric_value))
+      max_num_delayable_while_layout_blocking_ = numeric_value;
+    if (base::StringToSizeT(resource_priorities_split_group[4], &numeric_value))
+      max_num_delayable_requests_ = numeric_value;
+  }
 }
 
 ResourceScheduler::~ResourceScheduler() {
   DCHECK(unowned_requests_.empty());
   DCHECK(client_map_.empty());
 }
 
 void ResourceScheduler::SetThrottleOptionsForTesting(bool should_throttle,
                                                      bool should_coalesce) {
   should_coalesce_ = should_coalesce;
@@ skipping 53 matching lines @@
 }
 
 void ResourceScheduler::OnClientCreated(int child_id,
                                         int route_id,
                                         bool is_visible,
                                         bool is_audible) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
   DCHECK(!ContainsKey(client_map_, client_id));
 
-  Client* client = new Client(this, is_visible, is_audible);
+  Client* client = new Client(this, is_visible, is_audible,
+      layout_blocking_priority_threshold_, enable_layout_blocking_threshold_,
+      in_flight_layout_blocking_threshold_,
+      max_num_delayable_while_layout_blocking_, max_num_delayable_requests_);
   client_map_[client_id] = client;
 
   client->UpdateThrottleState();
 }
 
 void ResourceScheduler::OnClientDeleted(int child_id, int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
   DCHECK(ContainsKey(client_map_, client_id));
   ClientMap::iterator it = client_map_.find(client_id);
@@ skipping 231 matching lines @@
   client->ReprioritizeRequest(
       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