Remove HTTP pipelining support.

net/http/http_stream_factory_impl_request.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 "net/http/http_stream_factory_impl_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/http_stream_factory_impl_job.h"
@@ skipping 30 matching lines @@
     DCHECK(jobs_.empty());
   else
     DCHECK(!jobs_.empty());
 
   net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_REQUEST);
 
   for (std::set<Job*>::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     factory_->request_map_.erase(*it);
 
   RemoveRequestFromSpdySessionRequestMap();
-  RemoveRequestFromHttpPipeliningRequestMap();
 
   STLDeleteElements(&jobs_);
 }
 
 void HttpStreamFactoryImpl::Request::SetSpdySessionKey(
     const SpdySessionKey& spdy_session_key) {
   DCHECK(!spdy_session_key_.get());
   spdy_session_key_.reset(new SpdySessionKey(spdy_session_key));
   RequestSet& request_set =
       factory_->spdy_session_request_map_[spdy_session_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
 }
 
-bool HttpStreamFactoryImpl::Request::SetHttpPipeliningKey(
-    const HttpPipelinedHost::Key& http_pipelining_key) {
-  CHECK(!http_pipelining_key_.get());
-  http_pipelining_key_.reset(new HttpPipelinedHost::Key(http_pipelining_key));
-  bool was_new_key = !ContainsKey(factory_->http_pipelining_request_map_,
-                                  http_pipelining_key);
-  RequestVector& request_vector =
-      factory_->http_pipelining_request_map_[http_pipelining_key];
-  request_vector.push_back(this);
-  return was_new_key;
-}
-
 void HttpStreamFactoryImpl::Request::AttachJob(Job* job) {
   DCHECK(job);
   jobs_.insert(job);
   factory_->request_map_[job] = this;
 }
 
 void HttpStreamFactoryImpl::Request::Complete(
     bool was_npn_negotiated,
     NextProto protocol_negotiated,
     bool using_spdy,
@@ skipping 36 matching lines @@
   OnJobSucceeded(job);
   delegate_->OnWebSocketHandshakeStreamReady(
       used_ssl_config, used_proxy_info, stream);
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamFailed(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config) {
   DCHECK_NE(OK, status);
-  // |job| should only be NULL if we're being canceled by a late bound
-  // HttpPipelinedConnection (one that was not created by a job in our |jobs_|
-  // set).
-  if (!job) {
-    DCHECK(!bound_job_.get());
-    DCHECK(!jobs_.empty());
-    // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because
-    // we *WANT* to cancel the unnecessary Jobs from other requests if another
-    // Job completes first.
-  } else if (!bound_job_.get()) {
+  DCHECK(job);
+  if (!bound_job_.get()) {
     // Hey, we've got other jobs! Maybe one of them will succeed, let's just
     // ignore this failure.
     if (jobs_.size() > 1) {
       jobs_.erase(job);
       factory_->request_map_.erase(job);
       delete job;
       return;
     } else {
       bound_job_.reset(job);
       jobs_.erase(job);
@@ skipping 107 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_));
-    RequestVector& request_vector =
-        http_pipelining_request_map[*http_pipelining_key_];
-    for (RequestVector::iterator it = request_vector.begin();
-         it != request_vector.end(); ++it) {
-      if (*it == this) {
-        request_vector.erase(it);
-        break;
-      }
-    }
-    if (request_vector.empty())
-      http_pipelining_request_map.erase(*http_pipelining_key_);
-    http_pipelining_key_.reset();
-  }
-}
-
 void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady(
     Job* job,
     scoped_ptr<HttpStream> stream,
     const base::WeakPtr<SpdySession>& spdy_session,
     bool direct) {
   DCHECK(job);
   DCHECK(job->using_spdy());
 
   // Note: |spdy_session| may be NULL. In that case, |delegate_| should still
   // receive |stream| so the error propogates up correctly, however there is no
@@ skipping 47 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);
 }
 
 void HttpStreamFactoryImpl::Request::OnJobSucceeded(Job* job) {
   // |job| should only be NULL if we're being serviced by a late bound
-  // SpdySession or HttpPipelinedConnection (one that was not created by a job
-  // in our |jobs_| set).
+  // SpdySession (one that was not created by a job in our |jobs_| set).
   if (!job) {
     DCHECK(!bound_job_.get());
     DCHECK(!jobs_.empty());
     // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because
     // we *WANT* to cancel the unnecessary Jobs from other requests if another
     // Job completes first.
     // TODO(mbelshe): Revisit this when we implement ip connection pooling of
     // SpdySessions. Do we want to orphan the jobs for a different hostname so
     // they complete? Or do we want to prevent connecting a new SpdySession if
     // we've already got one available for a different hostname where the ip
     // address matches up?
     return;
   }
   if (!bound_job_.get()) {
     if (jobs_.size() > 1)
       job->ReportJobSuccededForRequest();
     // We may have other jobs in |jobs_|. For example, if we start multiple jobs
     // for Alternate-Protocol.
     OrphanJobsExcept(job);
     return;
   }
   DCHECK(jobs_.empty());
 }
 
 }  // namespace net