Disabled resource scheduling when using a SPDY proxy

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 "base/stl_util.h"
 #include "content/common/resource_messages.h"
 #include "content/browser/loader/resource_message_delegate.h"
 #include "content/public/browser/resource_controller.h"
@@ skipping 116 matching lines @@
   net::URLRequest* request_;
   bool ready_;
   bool deferred_;
   ResourceScheduler* scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScheduledResourceRequest);
 };
 
 // Each client represents a tab.
 struct ResourceScheduler::Client {
-  Client() : has_body(false) {}
+  Client() : has_body(false), using_spdy_proxy(false) {}
   ~Client() {}
 
   bool has_body;
+  bool using_spdy_proxy;
   RequestQueue pending_requests;
   RequestSet in_flight_requests;
 };
 
 ResourceScheduler::ResourceScheduler() {
 }
 
 ResourceScheduler::~ResourceScheduler() {
   DCHECK(unowned_requests_.empty());
   DCHECK(client_map_.empty());
@@ skipping 35 matching lines @@
     return;
   }
 
   ClientMap::iterator client_it = client_map_.find(request->client_id());
   if (client_it == client_map_.end()) {
     return;
   }
 
   Client* client = client_it->second;
 
+  if (!client->using_spdy_proxy) {
+    net::HttpResponseInfo response_info =
+        request->url_request()->response_info();
+    if (response_info.was_fetched_via_spdy &&
+        response_info.was_fetched_via_proxy) {

[James Simonsen, 2013/12/02 18:59:31]

Is this really the only way to determine it? It seems unfortunate we have to
wait so long. How does the network stack decide to use SPDY proxy? Can we
extract that code instead?

[Pat Meenan, 2013/12/02 19:35:51]

This is the lowest-impact way I could come up with (there's a thread on
chromium-dev with Will Chan and Ryan Sleevi:
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/ziP_vgEQ2AQ
).

The network stack needs to walk through the configured proxies, execute any PAC
scripts and then only after the TLS negotiation with the host is complete do we
know it's actually a SPDY proxy which is way more overhead than we want to do
here.

It isn't quite as bad as it seems.  We can only discover the resources after the
first request starts to come back so the lost opportunity is between the TTFB
and when the base page (or any script or other request) completes at which point
we'd open the flood-gates.  It's a bit conservative but should get most of the
benefit and we can improve it further for some cases if we think it's worthwhile
(like the data reduction proxy).

+      client->using_spdy_proxy = true;
+    }
+  }
+
   if (client->pending_requests.IsQueued(request)) {
     client->pending_requests.Erase(request);
     DCHECK(!ContainsKey(client->in_flight_requests, request));
   } else {
     size_t erased = client->in_flight_requests.erase(request);
     DCHECK(erased);
 
     // Removing this request may have freed up another to load.
     LoadAnyStartablePendingRequests(client);
   }
@@ skipping 32 matching lines @@
   ClientId client_id = MakeClientId(child_id, route_id);
 
   ClientMap::iterator it = client_map_.find(client_id);
   if (it == client_map_.end()) {
     // The client was likely deleted shortly before we received this IPC.
     return;
   }
 
   Client* client = it->second;
   client->has_body = false;
+  client->using_spdy_proxy = false;
 }
 
 void ResourceScheduler::OnWillInsertBody(int child_id, int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
 
   ClientMap::iterator it = client_map_.find(client_id);
   if (it == client_map_.end()) {
     // The client was likely deleted shortly before we received this IPC.
     return;
@@ skipping 90 matching lines @@
 bool ResourceScheduler::ShouldStartRequest(ScheduledResourceRequest* request,
                                            Client* client) const {
   const net::URLRequest& url_request = *request->url_request();
 
   // TODO(simonjam): This may end up causing disk contention. We should
   // experiment with throttling if that happens.
   if (!url_request.url().SchemeIsHTTPOrHTTPS()) {
     return true;
   }
 
+  if (client->using_spdy_proxy) {
+    return true;
+  }
+
   const 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 SPDY request
   // against the delayable requests limit.
   bool origin_supports_spdy = http_server_properties.SupportsSpdy(
       net::HostPortPair::FromURL(url_request.url()));
 
   if (url_request.priority() >= net::LOW ||
@@ skipping 17 matching lines @@
 
   return true;
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content