Basic HTTP pipelining support

net/http/http_pipelined_host.cc

Index: net/http/http_pipelined_host.cc
diff --git a/net/http/http_pipelined_host.cc b/net/http/http_pipelined_host.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d17a7f5b9356a713761807a1cd78ac12d698a5de
--- /dev/null
+++ b/net/http/http_pipelined_host.cc
@@ -0,0 +1,93 @@
+// Copyright (c) 2011 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 "net/http/http_pipelined_host.h"
+
+#include "base/stl_util.h"
+#include "net/http/http_pipelined_connection_impl.h"
+#include "net/http/http_pipelined_stream.h"
+
+namespace net {
+
+class HttpPipelinedConnectionImplFactory :
+    public HttpPipelinedConnection::Factory {
+ public:
+   HttpPipelinedConnection* CreateNewPipeline(
+       ClientSocketHandle* connection,
+       HttpPipelinedConnection::Delegate* delegate,
+       const SSLConfig& used_ssl_config,
+       const ProxyInfo& used_proxy_info,
+       const BoundNetLog& net_log,
+       bool was_npn_negotiated) OVERRIDE {
+     return new HttpPipelinedConnectionImpl(connection, delegate,
+                                            used_ssl_config, used_proxy_info,
+                                            net_log, was_npn_negotiated);
+   }
+};
+
+HttpPipelinedHost::HttpPipelinedHost(
+    HttpPipelinedHost::Delegate* delegate,
+    const HostPortPair& origin,
+    HttpPipelinedConnection::Factory* factory)
+    : delegate_(delegate),
+      origin_(origin),
+      factory_(factory) {
+  if (!factory_) {
+    factory_ = new HttpPipelinedConnectionImplFactory();

[willchan no longer on Chromium, 2011/09/26 23:49:20]

Who owns this? Where is this deleted?

[James Simonsen, 2011/09/29 02:39:31]

Done.

+  }
+}
+
+HttpPipelinedHost::~HttpPipelinedHost() {
+  DCHECK(pipelines_.empty());
+}
+
+HttpPipelinedConnection* HttpPipelinedHost::CreateNewPipeline(
+    ClientSocketHandle* connection,
+    const SSLConfig& used_ssl_config,
+    const ProxyInfo& used_proxy_info,
+    const BoundNetLog& net_log,
+    bool was_npn_negotiated) {
+  HttpPipelinedConnection* pipeline = factory_->CreateNewPipeline(
+      connection, this, used_ssl_config, used_proxy_info, net_log,
+      was_npn_negotiated);
+  pipelines_.insert(pipeline);
+  return pipeline;
+}
+
+HttpPipelinedConnection* HttpPipelinedHost::FindAvailablePipeline() {
+  HttpPipelinedConnection* available_pipeline = NULL;
+  for (std::set<HttpPipelinedConnection*>::iterator it = pipelines_.begin();
+       it != pipelines_.end(); ++it) {
+    if ((*it)->usable() &&
+        (*it)->active() &&
+        (*it)->depth() < max_pipeline_depth() &&
+        (!available_pipeline || (*it)->depth() < available_pipeline->depth())) {
+      available_pipeline = *it;
+    }
+  }
+  return available_pipeline;
+}
+
+void HttpPipelinedHost::OnPipelineEmpty(HttpPipelinedConnection* pipeline) {
+  DCHECK(ContainsKey(pipelines_, pipeline));
+  pipelines_.erase(pipeline);
+  delete pipeline;
+  if (pipelines_.empty()) {
+    delegate_->OnHostIdle(this);
+    // WARNING: We'll probably be deleted here.
+  }
+}
+
+void HttpPipelinedHost::OnPipelineHasCapacity(
+    HttpPipelinedConnection* pipeline) {
+  if (pipeline->usable() && pipeline->depth() < max_pipeline_depth()) {
+    delegate_->OnHostHasAdditionalCapacity(this);
+  }
+  if (!pipeline->depth()) {
+    OnPipelineEmpty(pipeline);
+    // WARNING: We'll probably be deleted here.

[willchan no longer on Chromium, 2011/09/26 23:49:20]

Interesting. So when pipelines go empty, we don't preserve the
HttpPipelinedConnection in its HTTP keep alive idle state? That's fine as an
initial implementation, but I would think that we should fix that in the future.
Adding a TODO somewhere to remember that would be great. I would actually prefer
you not implement it yet so we can keep this changelist manageable :)

[James Simonsen, 2011/09/29 02:39:31]

Done. Yeah, I definitely intend to track what we learn about hosts. My plan is
still to just release the connection back to the normal socket pool, but
remember that pipelining works for this host. So, the next time we need
something from that host, we'll just immediately start off with pipelining
instead of going through the soon-to-be-added heuristics.

+  }
+}
+
+}  // namespace net