Fix Resource Priorities and Scheduling (Chrome Side)

content/browser/loader/resource_scheduler.h

 // 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.
 
 #ifndef CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_
 #define CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_
 
 #include <map>
 #include <set>
 
@@ skipping 147 matching lines @@
   bool limit_outstanding_requests() const {
     return limit_outstanding_requests_;
   }
 
   // Returns the outstanding request limit.  Only valid if
   // |IsLimitingOutstandingRequests()|.
   size_t outstanding_request_limit() const {
     return outstanding_request_limit_;
   }
 
+  // Returns the priority level above which resources are considered
+  // layout-blocking if the html_body has not started.  It is also the threshold
+  // below which resources are considered delayable (and for completeness,
+  // a request that matches the threshold level is a high-priority but not
+  // layout-blocking request).

[mmenke, 2015/08/13 15:16:07]

That's actually not true - "in_flight_layout_blocking_threshold" is compared to
"non_delayable_requests_in_flight_count" rather than
"total_layout_blocking_count_".

[Pat Meenan, 2015/08/13 20:56:42]

Thanks - managed to confuse myself apparently.  Changed it to
in_flight_non_delayable because
enable_in_flight_layout_blocking_or_high_priority_threshold was just about
impossible to fit in 80 characters and it makes the comparison cleaner.

+  net::RequestPriority layout_blocking_or_high_priority_threshold() const {
+    return layout_blocking_or_high_priority_threshold_;
+  }
+
+  // Returns true if all delayable requests should be blocked while at least
+  // in_flight_layout_blocking_threshold() layout-blocking requests are
+  // in-flight during the layout-blocking phase of loading.
+  bool enable_in_flight_layout_blocking_threshold() const {
+    return enable_in_flight_layout_blocking_threshold_;
+  }
+
+  // Returns the number of in-flight layout-blocking requests above which
+  // all delayable requests should be blocked when
+  // enable_layout_blocking_threshold is set.
+  size_t in_flight_layout_blocking_threshold() const {
+    return in_flight_layout_blocking_threshold_;
+  }
+
+  // Returns the maximum number of delayable requests to allow be in-flight
+  // at any point in time while in the layout-blocking phase of loading.
+  size_t max_num_delayable_while_layout_blocking() const {
+    return max_num_delayable_while_layout_blocking_;
+  }
+
+  // Returns the maximum number of delayable requests to all be in-flight at
+  // any point in time (across all hosts).
+  size_t max_num_delayable_requests() const {
+    return max_num_delayable_requests_;
+  }
+
   enum ClientState {
     // Observable client.
     ACTIVE,
     // Non-observable client.
     BACKGROUND,
     // No client found.
     UNKNOWN,
   };
 
   class RequestQueue;
@@ skipping 53 matching lines @@
   // Returns the client for the given |child_id| and |route_id| combo.
   Client* GetClient(int child_id, int route_id);
 
   bool should_coalesce_;
   bool should_throttle_;
   ClientMap client_map_;
   size_t active_clients_loading_;
   size_t coalesced_clients_;
   bool limit_outstanding_requests_;
   size_t outstanding_request_limit_;
+  net::RequestPriority layout_blocking_or_high_priority_threshold_;
+  bool enable_in_flight_layout_blocking_threshold_;
+  size_t in_flight_layout_blocking_threshold_;
+  size_t max_num_delayable_while_layout_blocking_;
+  size_t max_num_delayable_requests_;
   // This is a repeating timer to initiate requests on COALESCED Clients.
   scoped_ptr<base::Timer> coalescing_timer_;
   RequestSet unowned_requests_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_