Remove HTTP pipelining support.

net/http/http_stream_factory_impl_job.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_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_session.h"
-#include "net/http/http_pipelined_connection.h"
-#include "net/http/http_pipelined_host.h"
-#include "net/http/http_pipelined_host_pool.h"
-#include "net/http/http_pipelined_stream.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_manager.h"
@@ skipping 63 matching lines @@
       quic_request_(session_->quic_stream_factory()),
       using_existing_quic_session_(false),
       force_spdy_always_(HttpStreamFactory::force_spdy_always()),
       force_spdy_over_ssl_(HttpStreamFactory::force_spdy_over_ssl()),
       spdy_certificate_error_(OK),
       establishing_tunnel_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
-      existing_available_pipeline_(false),
       ptr_factory_(this) {
   DCHECK(stream_factory);
   DCHECK(session);
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
   net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB);
 
   // When we're in a partially constructed state, waiting for the user to
   // provide certificate handling information or authentication, we can't reuse
@@ skipping 488 matching lines @@
   int rv = RunLoop(OK);
   DCHECK_EQ(ERR_IO_PENDING, rv);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::DoStart() {
   int port = request_info_.url.EffectiveIntPort();
   origin_ = HostPortPair(request_info_.url.HostNoBrackets(), port);
   origin_url_ = stream_factory_->ApplyHostMappingRules(
       request_info_.url, &origin_);
-  http_pipelining_key_.reset(new HttpPipelinedHost::Key(origin_));
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
                       base::Bind(&NetLogHttpStreamJobCallback,
                                  &request_info_.url, &origin_url_,
                                  priority_));
 
   // Don't connect to restricted ports.
   bool is_port_allowed = IsPortAllowedByDefault(port);
   if (request_info_.url.SchemeIs("ftp")) {
     // Never share connection with other jobs for FTP requests.
@@ skipping 147 matching lines @@
     // actually need to preconnect any sockets, so we're done.
     if (IsPreconnecting())
       return OK;
     using_spdy_ = true;
     next_state_ = STATE_CREATE_STREAM;
     existing_spdy_session_ = spdy_session;
     return OK;
   } else if (request_ && (using_ssl_ || ShouldForceSpdyWithoutSSL())) {
     // Update the spdy session key for the request that launched this job.
     request_->SetSpdySessionKey(spdy_session_key);
-  } else if (IsRequestEligibleForPipelining()) {
-    // TODO(simonjam): With pipelining, we might be better off using fewer
-    // connections and thus should make fewer preconnections. Explore
-    // preconnecting fewer than the requested num_connections.
-    //
-    // Separate note: A forced pipeline is always available if one exists for
-    // this key. This is different than normal pipelines, which may be
-    // unavailable or unusable. So, there is no need to worry about a race
-    // between when a pipeline becomes available and when this job blocks.
-    existing_available_pipeline_ = stream_factory_->http_pipelined_host_pool_.
-        IsExistingPipelineAvailableForKey(*http_pipelining_key_.get());
-    if (existing_available_pipeline_) {
-      return OK;
-    } else {
-      bool was_new_key = request_->SetHttpPipeliningKey(
-          *http_pipelining_key_.get());
-      if (!was_new_key && session_->force_http_pipelining()) {
-        return ERR_IO_PENDING;
-      }
-    }
   }
 
   // OK, there's no available SPDY session. Let |waiting_job_| resume if it's
   // paused.
 
   if (waiting_job_) {
     waiting_job_->Resume(this);
     waiting_job_ = NULL;
   }
 
@@ skipping 84 matching lines @@
     return OK;
   }
 
   // TODO(willchan): Make this a bit more exact. Maybe there are recoverable
   // errors, such as ignoring certificate errors for Alternate-Protocol.
   if (result < 0 && waiting_job_) {
     waiting_job_->Resume(this);
     waiting_job_ = NULL;
   }
 
-  if (result < 0 && session_->force_http_pipelining()) {
-    stream_factory_->AbortPipelinedRequestsWithKey(
-        this, *http_pipelining_key_.get(), result, server_ssl_config_);
-  }
-
   // |result| may be the result of any of the stacked pools. The following
   // logic is used when determining how to interpret an error.
   // If |result| < 0:
   //   and connection_->socket() != NULL, then the SSL handshake ran and it
   //     is a potentially recoverable error.
   //   and connection_->socket == NULL and connection_->is_ssl_error() is true,
   //     then the SSL handshake ran with an unrecoverable error.
   //   otherwise, the error came from one of the other pools.
   bool ssl_started = using_ssl_ && (result == OK || connection_->socket() ||
                                     connection_->is_ssl_error());
@@ skipping 113 matching lines @@
 int HttpStreamFactoryImpl::Job::DoWaitingUserAction(int result) {
   // This state indicates that the stream request is in a partially
   // completed state, and we've called back to the delegate for more
   // information.
 
   // We're always waiting here for the delegate to call us back.
   return ERR_IO_PENDING;
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStream() {
-  DCHECK(connection_->socket() || existing_spdy_session_.get() ||
-         existing_available_pipeline_ || using_quic_);
+  DCHECK(connection_->socket() || existing_spdy_session_.get() || using_quic_);
 
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
 
   // We only set the socket motivation if we're the first to use
   // this socket.  Is there a race for two SPDY requests?  We really
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   if (!using_spdy_) {
     // We may get ftp scheme when fetching ftp resources through proxy.
     bool using_proxy = (proxy_info_.is_http() || proxy_info_.is_https()) &&
                        (request_info_.url.SchemeIs("http") ||
                         request_info_.url.SchemeIs("ftp"));
-    if (stream_factory_->http_pipelined_host_pool_.
-            IsExistingPipelineAvailableForKey(*http_pipelining_key_.get())) {
-      DCHECK(!stream_factory_->for_websockets_);
-      stream_.reset(stream_factory_->http_pipelined_host_pool_.
-                    CreateStreamOnExistingPipeline(
-                        *http_pipelining_key_.get()));
-      CHECK(stream_.get());
-    } else if (stream_factory_->for_websockets_) {
+    if (stream_factory_->for_websockets_) {
       DCHECK(request_);
       DCHECK(request_->websocket_handshake_stream_create_helper());
       websocket_stream_.reset(
           request_->websocket_handshake_stream_create_helper()
               ->CreateBasicStream(connection_.Pass(), using_proxy));
-    } else if (!using_proxy && IsRequestEligibleForPipelining()) {
-      // TODO(simonjam): Support proxies.
-      stream_.reset(
-          stream_factory_->http_pipelined_host_pool_.CreateStreamOnNewPipeline(
-              *http_pipelining_key_.get(),
-              connection_.release(),
-              server_ssl_config_,
-              proxy_info_,
-              net_log_,
-              was_npn_negotiated_,
-              protocol_negotiated_));
-      CHECK(stream_.get());
     } else {
       stream_.reset(new HttpBasicStream(connection_.release(), using_proxy));
     }
     return OK;
   }
 
   CHECK(!stream_.get());
 
   bool direct = true;
   const ProxyServer& proxy_server = proxy_info_.proxy_server();
@@ skipping 96 matching lines @@
 
   return ReconsiderProxyAfterError(result);
 }
 
 void HttpStreamFactoryImpl::Job::ReturnToStateInitConnection(
     bool close_connection) {
   if (close_connection && connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
 
-  if (request_) {
+  if (request_)
     request_->RemoveRequestFromSpdySessionRequestMap();
-    request_->RemoveRequestFromHttpPipeliningRequestMap();
-  }
 
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 void HttpStreamFactoryImpl::Job::SetSocketMotivation() {
   if (request_info_.motivation == HttpRequestInfo::PRECONNECT_MOTIVATED)
     connection_->socket()->SetSubresourceSpeculation();
   else if (request_info_.motivation == HttpRequestInfo::OMNIBOX_MOTIVATED)
     connection_->socket()->SetOmniboxSpeculation();
   // TODO(mbelshe): Add other motivations (like EARLY_LOAD_MOTIVATED).
@@ skipping 131 matching lines @@
   }
 
   int rv = session_->proxy_service()->ReconsiderProxyAfterError(
       request_info_.url, &proxy_info_, io_callback_, &pac_request_, net_log_);
   if (rv == OK || rv == ERR_IO_PENDING) {
     // If the error was during connection setup, there is no socket to
     // disconnect.
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
-    if (request_) {
+    if (request_)
       request_->RemoveRequestFromSpdySessionRequestMap();
-      request_->RemoveRequestFromHttpPipeliningRequestMap();
-    }
     next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     // TODO(eroman): This is a confusing contract, make it more obvious.
     rv = error;
   }
 
   return rv;
@@ skipping 88 matching lines @@
   } else if (original_url_) {
     // This job was the alternate protocol job, and hence won the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_WON_RACE);
   } else {
     // This job was the normal job, and hence the alternate protocol job lost
     // the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_LOST_RACE);
   }
 }
 
-bool HttpStreamFactoryImpl::Job::IsRequestEligibleForPipelining() {
-  if (IsPreconnecting() || !request_) {
-    return false;
-  }
-  if (stream_factory_->for_websockets_) {
-    return false;
-  }
-  if (session_->force_http_pipelining()) {
-    return true;
-  }
-  if (!session_->params().http_pipelining_enabled) {
-    return false;
-  }
-  if (using_ssl_) {
-    return false;
-  }
-  if (request_info_.method != "GET" && request_info_.method != "HEAD") {
-    return false;
-  }
-  if (request_info_.load_flags &
-      (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
-       net::LOAD_IS_DOWNLOAD)) {
-    // Avoid pipelining resources that may be streamed for a long time.
-    return false;
-  }
-  return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
-      *http_pipelining_key_.get());
-}
-
 }  // namespace net