Basic HTTP pipelining support

net/http/http_pipelined_host.cc

+// 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_.reset(new HttpPipelinedConnectionImplFactory());
+  }
+}
+
+HttpPipelinedHost::~HttpPipelinedHost() {
+  CHECK(pipelines_.empty());
+}
+
+HttpPipelinedStream* HttpPipelinedHost::CreateStreamOnNewPipeline(
+    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->CreateNewStream();
+}
+
+HttpPipelinedStream* HttpPipelinedHost::CreateStreamOnExistingPipeline() {
+  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;
+    }
+  }
+  if (!available_pipeline) {
+    return NULL;
+  }
+  return available_pipeline->CreateNewStream();
+}
+
+bool HttpPipelinedHost::IsExistingPipelineAvailable() {
+  for (std::set<HttpPipelinedConnection*>::iterator it = pipelines_.begin();
+       it != pipelines_.end(); ++it) {
+    if ((*it)->usable() &&
+        (*it)->active() &&
+        (*it)->depth() < max_pipeline_depth()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void HttpPipelinedHost::OnPipelineEmpty(HttpPipelinedConnection* pipeline) {
+  CHECK(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 might be deleted here.
+  }
+}
+
+}  // namespace net