Experiment with delaying requests fetched from spdy/h2/quic proxies

This experiment affects only http resources that
are fetched from a SPDY/H2/QUIC proxies.

Cq-Include-Trybots: master.tryserver.chromium.linux:linux_mojo
Change-Id: Ifee25862f6720669536b0467c22218d0eb63b1f5
Bug: 826558
Reviewed-on: https://chromium-review.googlesource.com/907669Reviewed-by: Matt Menke <mmenke@chromium.org>
Commit-Queue: Tarun Bansal <tbansal@chromium.org>
Cr-Commit-Position: refs/heads/master@{#546934}

services/network/resource_scheduler.cc

@@ -46,6 +46,12 @@ namespace {
 const base::Feature kPrioritySupportedRequestsDelayable{
     "PrioritySupportedRequestsDelayable", base::FEATURE_DISABLED_BY_DEFAULT};
 
+// When kSpdyProxiesRequestsDelayable is enabled, HTTP requests fetched from
+// a SPDY/QUIC/H2 proxies can be delayed by the ResourceScheduler just as
+// HTTP/1.1 resources are.
+const base::Feature kSpdyProxiesRequestsDelayable{
+    "SpdyProxiesRequestsDelayable", base::FEATURE_DISABLED_BY_DEFAULT};
+
 // When enabled, low-priority H2 and QUIC requests are throttled, but only
 // when the parser is in head.
 const base::Feature kHeadPrioritySupportedRequestsDelayable{
@@ -399,7 +405,9 @@ class ResourceScheduler::Client {
  public:
   Client(const net::NetworkQualityEstimator* const network_quality_estimator,
          ResourceScheduler* resource_scheduler)
-      : deprecated_is_loaded_(false),
+      : spdy_proxy_requests_delayble_(
+            base::FeatureList::IsEnabled(kSpdyProxiesRequestsDelayable)),
+        deprecated_is_loaded_(false),
         deprecated_has_html_body_(false),
         using_spdy_proxy_(false),
         in_flight_delayable_count_(0),
@@ -507,6 +515,11 @@ class ResourceScheduler::Client {
   }
 
   void OnReceivedSpdyProxiedHttpResponse() {
+    // If the requests to SPDY/H2/QUIC proxies are delayable, then return
+    // immediately.
+    if (spdy_proxy_requests_delayble_)
+      return;
+
     if (!using_spdy_proxy_) {
       using_spdy_proxy_ = true;
       LoadAnyStartablePendingRequests(RequestStartTrigger::SPDY_PROXY_DETECTED);
@@ -960,6 +973,10 @@ class ResourceScheduler::Client {
     }
   }
 
+  // True if requests to SPDY/H2/QUIC proxies can be delayed by the
+  // ResourceScheduler just as HTTP/1.1 resources are.
+  const bool spdy_proxy_requests_delayble_;
+
   bool deprecated_is_loaded_;
   // Tracks if the main HTML parser has reached the body which marks the end of
   // layout-blocking resources.

services/network/resource_scheduler_unittest.cc

@@ -2024,6 +2024,66 @@ TEST_F(ResourceSchedulerTest, NumDelayableAtStartOfNonDelayableUMA) {
       1);
 }
 
+TEST_F(ResourceSchedulerTest,
+       SpdyProxiesRequestsDelayableFeatureEnabled_DelaysSpdyProxyRequests) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitFromCommandLine("SpdyProxiesRequestsDelayable", "");
+  InitializeScheduler();
+
+  std::unique_ptr<TestRequest> high(
+      NewRequest("http://host/high", net::HIGHEST));
+  std::unique_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
+
+  std::unique_ptr<TestRequest> request(
+      NewRequest("http://host/req", net::IDLE));
+  EXPECT_FALSE(request->started());
+
+  scheduler()->OnReceivedSpdyProxiedHttpResponse(kChildId, kRouteId);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(request->started());
+
+  // Low priority requests are not started even though the page is loaded from
+  // an H2 proxy.
+  std::unique_ptr<TestRequest> after(
+      NewRequest("http://host/after", net::IDLE));
+  EXPECT_FALSE(after->started());
+
+  // High priority requests should still be scheduled immediately.
+  std::unique_ptr<TestRequest> high_2(
+      NewRequest("http://host/high", net::HIGHEST));
+  EXPECT_TRUE(high_2->started());
+}
+
+TEST_F(
+    ResourceSchedulerTest,
+    SpdyProxiesRequestsDelayableFeatureDisabled_SpdyProxyRequestsScheduledImmediately) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitFromCommandLine("", "SpdyProxiesRequestsDelayable");
+  InitializeScheduler();
+
+  std::unique_ptr<TestRequest> high(
+      NewRequest("http://host/high", net::HIGHEST));
+  std::unique_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
+
+  std::unique_ptr<TestRequest> request(
+      NewRequest("http://host/req", net::IDLE));
+  EXPECT_FALSE(request->started());
+
+  scheduler()->OnReceivedSpdyProxiedHttpResponse(kChildId, kRouteId);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(request->started());
+
+  // Low priority requests are started since the page is loaded from an H2
+  // proxy.
+  std::unique_ptr<TestRequest> after(
+      NewRequest("http://host/after", net::IDLE));
+  EXPECT_TRUE(after->started());
+
+  std::unique_ptr<TestRequest> high_2(
+      NewRequest("http://host/high", net::HIGHEST));
+  EXPECT_TRUE(high_2->started());
+}
+
 TEST_F(ResourceSchedulerTest, SchedulerEnabled) {
   std::unique_ptr<TestRequest> high(
       NewRequest("http://host/high", net::HIGHEST));