Basic HTTP pipelining support

net/http/http_stream_factory_impl_request.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_stream_factory_impl_request.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/spdy/spdy_http_stream.h"
@@ skipping 25 matching lines @@
     DCHECK(!jobs_.empty());
 
   net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_REQUEST, NULL);
 
   for (std::set<Job*>::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     factory_->request_map_.erase(*it);
 
   STLDeleteElements(&jobs_);
 
   RemoveRequestFromSpdySessionRequestMap();
+  RemoveRequestFromHttpPipeliningRequestMap();
 }
 
 void HttpStreamFactoryImpl::Request::SetSpdySessionKey(
     const HostPortProxyPair& spdy_session_key) {
   DCHECK(!spdy_session_key_.get());
   spdy_session_key_.reset(new HostPortProxyPair(spdy_session_key));
   RequestSet& request_set =
       factory_->spdy_session_request_map_[spdy_session_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
 }
 
+void HttpStreamFactoryImpl::Request::SetHttpPipeliningKey(
+    const HostPortPair& http_pipelining_key) {
+  DCHECK(!http_pipelining_key_.get());
+  http_pipelining_key_.reset(new HostPortPair(http_pipelining_key));
+  RequestSet& request_set =
+      factory_->http_pipelining_request_map_[http_pipelining_key];
+  DCHECK(!ContainsKey(request_set, this));
+  request_set.insert(this);
+}
+
 void HttpStreamFactoryImpl::Request::AttachJob(Job* job) {
   DCHECK(job);
   jobs_.insert(job);
   factory_->request_map_[job] = this;
 }
 
 void HttpStreamFactoryImpl::Request::Complete(
     bool was_npn_negotiated,
     bool using_spdy,
     const NetLog::Source& job_source) {
@@ skipping 150 matching lines @@
     RequestSet& request_set =
         spdy_session_request_map[*spdy_session_key_];
     DCHECK(ContainsKey(request_set, this));
     request_set.erase(this);
     if (request_set.empty())
       spdy_session_request_map.erase(*spdy_session_key_);
     spdy_session_key_.reset();
   }
 }
 
+void
+HttpStreamFactoryImpl::Request::RemoveRequestFromHttpPipeliningRequestMap() {
+  if (http_pipelining_key_.get()) {
+    HttpPipeliningRequestMap& http_pipelining_request_map =
+        factory_->http_pipelining_request_map_;
+    DCHECK(ContainsKey(http_pipelining_request_map, *http_pipelining_key_));
+    RequestSet& request_set =
+        http_pipelining_request_map[*http_pipelining_key_];
+    DCHECK(ContainsKey(request_set, this));
+    request_set.erase(this);
+    if (request_set.empty())
+      http_pipelining_request_map.erase(*http_pipelining_key_);
+    http_pipelining_key_.reset();
+  }
+}
+
 void HttpStreamFactoryImpl::Request::OnSpdySessionReady(
     Job* job,
     scoped_refptr<SpdySession> spdy_session,
     bool direct) {
   DCHECK(job);
   DCHECK(job->using_spdy());
 
   // The first case is the usual case.
   if (!bound_job_.get()) {
     OrphanJobsExcept(job);
@@ skipping 33 matching lines @@
   DCHECK(ContainsKey(jobs_, job));
   bound_job_.reset(job);
   jobs_.erase(job);
   factory_->request_map_.erase(job);
 
   OrphanJobs();
 }
 
 void HttpStreamFactoryImpl::Request::OrphanJobs() {
   RemoveRequestFromSpdySessionRequestMap();
+  RemoveRequestFromHttpPipeliningRequestMap();
 
   std::set<Job*> tmp;
   tmp.swap(jobs_);
 
   for (std::set<Job*>::iterator it = tmp.begin(); it != tmp.end(); ++it)
     factory_->OrphanJob(*it, this);
 }
 
 }  // namespace net