Slow start pipelining.

net/http/http_pipelined_host_pool.h

Index: net/http/http_pipelined_host_pool.h
diff --git a/net/http/http_pipelined_host_pool.h b/net/http/http_pipelined_host_pool.h
index 5e7c146efd76e93d07e9119e3ecd27d514c3cdcc..fb967421d840f7ed2e1f8afda9addb4599005e0c 100644
--- a/net/http/http_pipelined_host_pool.h
+++ b/net/http/http_pipelined_host_pool.h
@@ -9,22 +9,37 @@
 #include <map>
 
 #include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
+#include "base/memory/mru_cache.h"
+#include "base/memory/scoped_ptr.h"
 #include "net/http/http_pipelined_host.h"
 
 namespace net {
 
 class HostPortPair;
 class HttpPipelinedStream;
-class HttpStreamFactoryImpl;
 
 // Manages all of the pipelining state for specific host with active pipelined
 // HTTP requests. Manages connection jobs, constructs pipelined streams, and
 // assigns requests to the least loaded pipelined connection.
 class HttpPipelinedHostPool : public HttpPipelinedHost::Delegate {
  public:
-  explicit HttpPipelinedHostPool(HttpStreamFactoryImpl* factory);
+  class Delegate {
+   public:
+    // Called when a HttpPipelinedHost has new capacity. Attempts to allocate
+    // any pending pipeline-capable requests to pipelines.
+    virtual void OnHttpPipelinedHostHasAdditionalCapacity(
+        const HostPortPair& origin) = 0;
+  };
+
+  HttpPipelinedHostPool(Delegate* delegate,
+                        HttpPipelinedHost::Factory* factory);
   ~HttpPipelinedHostPool();
 
+  // Returns true if pipelining might work for |origin|. Generally, this returns
+  // true, unless |origin| is known to have failed pipelining recently.
+  bool IsHostEligibleForPipelining(const HostPortPair& origin);
+
   // Constructs a new pipeline on |connection| and returns a new
   // HttpPipelinedStream that uses it.
   HttpPipelinedStream* CreateStreamOnNewPipeline(
@@ -49,14 +64,22 @@ class HttpPipelinedHostPool : public HttpPipelinedHost::Delegate {
 
   virtual void OnHostHasAdditionalCapacity(HttpPipelinedHost* host) OVERRIDE;
 
+  virtual void OnHostDeterminedCapability(
+      HttpPipelinedHost* host,
+      HttpPipelinedHost::Capability capability) OVERRIDE;
+
  private:
+  typedef base::MRUCache<HostPortPair,
+                         HttpPipelinedHost::Capability> CapabilityMap;

[willchan no longer on Chromium, 2011/11/19 23:25:21]

I think you should be using HttpServerProperties here. This information strikes
me as being something that we want to persist. It sucks that we have to relearn
it each time. What do you think? We can keep it as a LRU cache, that makes
sense, but we should probably use the HttpServerProperties interface and
HttpServerPropertiesManager in chrome/browser/net to persist it.

Note that I'm also fine with you deferring this change to another changelist,
since you've already coded things up this way, and getting persistence working
separately is fine by me.

[James Simonsen, 2011/12/01 01:17:10]

Yeah, that's definitely the way it should be done. I'll start that now. I think
it'll probably be better to land separately, just to keep the changes in
reasonably sized chunks.

   typedef std::map<const HostPortPair, HttpPipelinedHost*> HostMap;
 
   HttpPipelinedHost* GetPipelinedHost(const HostPortPair& origin,
                                       bool create_if_not_found);
 
-  HttpStreamFactoryImpl* factory_;
+  Delegate* delegate_;
+  scoped_ptr<HttpPipelinedHost::Factory> factory_;
   HostMap host_map_;
+  CapabilityMap known_capability_map_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpPipelinedHostPool);
 };